【小家Spring】BeanFactory体系和ApplicationContext体系，两大体系各接口分析、区别和联系(上)

public interface BeanFactory {
  String FACTORY_BEAN_PREFIX = "&";
  Object getBean(String name) throws BeansException;
  <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
  Object getBean(String name, Object... args) throws BeansException;
  <T> T getBean(Class<T> requiredType) throws BeansException;
  <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
  //@since 4.1
  // 包含Bean定义或者包含单例Bean实例，都会返回true（不管这个Bean是具体的还是抽象的、lazy的还是eager的，in scope or not 都会返回true）
  boolean containsBean(String name);
  // 若是单例，getBean()每次都会返回同一个实例
  boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
  //@since 4.2
  // 名称为name的Bean的类型，是否和给定的类型匹配（4.2新增的重载接口，传的是ResolvableType ，更加强大了）
  boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
  boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
  // name对应的Bean的类型
  Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  // name对应的Bean的别名们（通过别名也可以依赖注入哦~~~）  通过alia别名，也可以getBean()
  String[] getAliases(String name);
}

// 返回指定bean的提供程序（Provider），允许延迟(这是重点)按需检索实例，包括可用性和唯一性选项
// @since 5.1
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
// @since 5.1
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

public interface HierarchicalBeanFactory extends BeanFactory {
  //返回本Bean工厂的父工厂（至于父工厂怎么设置进去的，却放在了三级接口（个人感觉是Spring的Bug哈哈））
  //这个方法实现了工厂的分层
  @Nullable
  BeanFactory getParentBeanFactory();
  //本地工厂是否包含这个Bean（忽略其他所有父工厂）。这也是分层思想的体现。
  boolean containsLocalBean(String name);
}

public interface ListableBeanFactory extends BeanFactory {
  // 这三个都是和Bean定义信息有关的方法
  boolean containsBeanDefinition(String beanName);
  int getBeanDefinitionCount();
  String[] getBeanDefinitionNames();
  //返回匹配给定类型（包括子类）的所有bean的名字，如果是普通bean，则是bean定义的名字，如果是 FactoryBean，则是其getObjectType方法返回的对象的名字
  // 这个方法只考虑最顶层的bean（top-level beans），内部嵌套的bean（nested beans）即便可能匹配指定的类型也不考虑（不支持内部类）
  // 在许多实现中，此方法返回的结果与调用getBeansOfType(type, true, true)一样
  // 这个方法返回的bean名称应该尽可能与后台配置的bean定义顺序一样
  // 此方法只会
  // 若没有符合条件的，返回的空数组，而不是null
  @since 4.2
  String[] getBeanNamesForType(ResolvableType type);
  // 同上
  String[] getBeanNamesForType(@Nullable Class<?> type);
  // includeNonSingletons：false表示只查单例Bean。true表示包含prototype或者其它Scope的Bean们
  // allowEagerInit：主要是解决FactoryBean的情况。若为false，只会去检查FactoryBean本身,若为true，FactoryBean本身和它的产生的对象都会被检查匹配
  // 上面的方法底层调用的为：return getBeanNamesForType(type, true, true); 所以上面方法是全拿（一般不建议调用）
  String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
  //返回匹配给定类型（包含子类）的实例，可能是通过bean定义创建，也可以是FactoryBean时其getObjectType返回（注意：此处返回的是实例了，不再是Bean定义了）
  //此方法仅考虑最顶层bean，不含其内部嵌套的bean，即使内部嵌套的bean匹配给定类型
  //此方法返回的结果与调用getBeansOfType(type, true, true)一样
  // 实现者：Map的顺序要尽最大可能的与配置时一样
  // 备注：此方法但凡一调用，即使有些Bean只是Bean定义的话，也会被立马初始化的~~~~~
  <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
  <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException;
  // 这个接口会把所有标注有指定注解的Bean的定义信息的BeanName返回
  //@since 4.0
  String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
  // 返回的实例~~~~
  Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
  //查找指定bean的指定类型的注解。
  // 注意：如果本类没找到，还会去它的接口、它的父类里面找，这个厉害了我的哥
  // getBeanNamesForAnnotation依赖于此接口
  @Nullable
  <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;
}

public interface AutowireCapableBeanFactory extends BeanFactory {
  // 用于标识外部自动装配功能是否可用。但是此标识不影响正常的（基于注解的等）自动装配功能的使用
  int AUTOWIRE_NO = 0; // 不注入
  int AUTOWIRE_BY_NAME = 1; // 根据名称注入
  int AUTOWIRE_BY_TYPE = 2; // 根据类型注入
  int AUTOWIRE_CONSTRUCTOR = 3; // 根据构造器注入
  @Deprecated
  int AUTOWIRE_AUTODETECT = 4; // 标识自动识别一种装配策略来实现自动装配（Spring3.0后废弃）
  //创建一个给定Class的实例。它会处理各种带有注解的域和方法，并且会调用所有Bean初始化时所需要调用的回调函数
  //它会执行所有的关于Bean生命周期的接口方法如BeanPostProcessor
  //此方法并不意味着by-name或者by-type方式的自动装配，如果需要使用这写功能，可以使用其下面的重载方法
  <T> T createBean(Class<T> beanClass) throws BeansException;
  // 和上面的区别为：创建这个Bean的时候可以指定autowireMode，然后可以把它需要注入的Bean都注入进来（这个Mode会放在Bean定义里，在依赖注入的时候会有用）
  // Bean定义的默认值为：autowireMode = AUTOWIRE_NO;显然是不会开启自动装配的
  // 在populateBean()给属性赋值（依赖注入的时候，会使用到此模式）
  Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  //通过调用给定Bean的after-instantiation及post-processing接口，对bean进行装配值
  // 此方法主要是用于处理Bean中带有注解的字段和方法。
  // 此方法并不意味着by-name或者by-type方式的自动装配，如果需要使用这些功能，可以使用其重载方法autowireBeanProperties
  // 只会调用populateBean
  void autowireBean(Object existingBean) throws BeansException;
  //通过指定的自动装配策略来初始化一个Bean 注意：他会创建一个新的Bean
  //需要注意的是：此方法不会调用Bean上注册的诸如BeanPostProcessors的回调方法
  // 只会调用populateBean
  Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
  //通过指定的自动装配方式来对给定的已经存在的Bean进行自动装配
  //不过会调用指定Bean注册的BeanPostProcessors等回调函数来初始化Bean。
  //如果指定装配方式为AUTOWIRE_NO的话，不会自动装配属性，但是，但是，但是依然会调用BeanPiostProcesser等回调方法。
  //只会调用populateBean
  void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException;
  //配置参数中指定的bean，包括自动装配其域，对其应用如setBeanName功能的回调函数。并且会调用其所有注册的post processor.
  // beanName表示在Bean定义中的名称。
  // populateBean和initializeBean都会被调用
  Object configureBean(Object existingBean, String beanName) throws BeansException;
  //简单的说，就是把Bean定义信息里面的一些东西，赋值到已经存在的Bean里面
  // 除了InstantiationAwareBeanPostProcessor的回调方法外，此方法不会在Bean上应用其它的例如BeanPostProcessors
  void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
  // 实例化这个Bean，会调用所有的postProcessors 方法
  Object initializeBean(Object existingBean, String beanName) throws BeansException;
  //调用参数中指定Bean的postProcessBeforeInitialization/postProcessorsAfterInitialization方法  初始化之前、之后
  Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;
  Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;
  //销毁参数中指定的Bean，同时调用此Bean上的DisposableBean和DestructionAwareBeanPostProcessors方法
  //在销毁途中，任何的异常情况都只应该被直接捕获和记录，而不应该向外抛出。
  void destroyBean(Object existingBean);
  //查找唯一符合指定类的实例，如果有，则返回实例的名字和实例本身
  //底层依赖于：BeanFactory中的getBean(Class)方法
  <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
  //解析出在Factory中与指定Bean有指定依赖关系的Bean（@Autowired依赖注入的核心方法）
  @Nullable
  Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
  //descriptor 依赖描述 (field/method/constructor)
  //requestingBeanName 依赖描述所属的Bean
  //autowiredBeanNames 与指定Bean有依赖关系的Bean
  //typeConverter 用以转换数组和连表的转换器
  //备注：结果可能为null，毕竟容器中可能不存在这个依赖嘛~~~~~~~~~~~~~~~~
  @Nullable
  Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}