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

public interface SingletonBeanRegistry {
  //以指定的名字将给定Object注册到BeanFactory中。
  //此接口相当于直接把Bean注册，所以都是准备好了的Bean。（动态的向容器里直接放置一个Bean）
  //什么BeanPostProcessor、InitializingBean、afterPropertiesSet等都不会被执行的，销毁的时候也不会收到destroy的信息
  void registerSingleton(String beanName, Object singletonObject);
  //以Object的形式返回指定名字的Bean，如果仅仅还是只有Bean定义信息，这里不会反悔
  // 需要注意的是：此方法不能直接通过别名获取Bean。若是别名，请通过BeanFactory的方法先获取到id
  @Nullable
  Object getSingleton(String beanName);
  //是否包含此单例Bean（不支持通过别名查找）
  boolean containsSingleton(String beanName);
  // 得到容器内所有的单例Bean的名字们
  String[] getSingletonNames();
  int getSingletonCount();
  // @since 4.2
  // 获取当前这个注册表的互斥量(mutex),使用者通过该互斥量协同访问当前注册表
  // 实现类DefaultSingletonBeanRegistry就一句话：return this.singletonObjects; 返回当前所有的单例Bean
  Object getSingletonMutex();
}

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
  //定义了两个作用域: 单例和原型.可以通过registerScope来添加.
  String SCOPE_SINGLETON = "singleton";
  String SCOPE_PROTOTYPE = "prototype";
  //父容器设置.而且一旦设置了就不让修改（改就抛错）
  // 配合父接口HierarchicalBeanFactory的getParentBeanFactory方法
  void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
  //类加载器设置与获取.默认使用当前线程中的类加载器
  void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
  @Nullable
  ClassLoader getBeanClassLoader();
  //为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器
  void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
  @Nullable
  ClassLoader getTempClassLoader();
  //设置、是否缓存元数据，如果false，那么每次请求实例，都会从类加载器重新加载（热加载）
  // 在字段mergedBeanDefinitions里存着，和getMergedBeanDefinition方法有关
  void setCacheBeanMetadata(boolean cacheBeanMetadata);
  boolean isCacheBeanMetadata();
  //定义用于解析bean definition的表达式解析器
  void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
  @Nullable
  BeanExpressionResolver getBeanExpressionResolver();
  //类型转化器
  void setConversionService(@Nullable ConversionService conversionService);
  @Nullable
  ConversionService getConversionService();
  //添加一个属性编辑器的登记员：Registrar
  void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
  //注册常用属性编辑器
  void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
  //用工厂中注册的通用的编辑器初始化指定的属性编辑注册器
  void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
  //BeanFactory用来转换bean属性值或者参数值的自定义转换器
  void setTypeConverter(TypeConverter typeConverter);
  TypeConverter getTypeConverter();
  //string值解析器(想起mvc中的ArgumentResolver了)
  //增加一个嵌入式的StringValueResolver
  void addEmbeddedValueResolver(StringValueResolver valueResolver);
  // 上面增加过，这里就是true嘛
  boolean hasEmbeddedValueResolver();
  // 用注册的值解析器，依次解析这个value(注意是依次解析)。谁先解析出为null了，后面就不再解析了
  @Nullable
  String resolveEmbeddedValue(String value);
  // 向工厂里添加Bean的后置处理器BeanPostProcessor 
  // 需要注意的是：内部实现是先执行remove，再add的设计技巧
  void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
  int getBeanPostProcessorCount();
  // 作用域定义：注册范围
  void registerScope(String scopeName, Scope scope);
  String[] getRegisteredScopeNames();
  @Nullable
  Scope getRegisteredScope(String scopeName);
  //访问权限控制：返回本工厂的一个安全访问上下文  和java.security有关的
  AccessControlContext getAccessControlContext();
  //从其他的工厂复制相关的所有配置
  void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
  //给指定的Bean注册别名  内部还会checkForAliasCircle(name, alias);
  void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
  void resolveAliases(StringValueResolver valueResolver);
  //合并bean定义,包括父容器的 返回合并后的Bean定义信息
  BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  //是否是FactoryBean类型  判断指定Bean是否为一个工厂Bean
  boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
  //bean创建状态控制.在解决循环依赖时有使用   设置一个Bean是否正在创建
  void setCurrentlyInCreation(String beanName, boolean inCreation);
  boolean isCurrentlyInCreation(String beanName);
  //处理bean依赖问题
  //注册一个依赖于指定bean的Bean
  void registerDependentBean(String beanName, String dependentBeanName);
  //返回依赖于指定Bean的所欲Bean名
  String[] getDependentBeans(String beanName);
  //返回指定Bean依赖的所有Bean名（注意和上面的区别，是反过来的）
  String[] getDependenciesForBean(String beanName);
  // 销毁的相关方法
  void destroyBean(String beanName, Object beanInstance);
  void destroyScopedBean(String beanName);
  //销毁所有的单例们
  void destroySingletons();
}

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
  // 忽略的自动注入的类型。也就是说这些类型不能@Autowired了
  void ignoreDependencyType(Class<?> type);
  // 忽略自动装配的接口
  void ignoreDependencyInterface(Class<?> ifc);
  // 注册一个可以给解析的依赖。这样子注入进去的，在Autowired的时候就可以被自动注入进去了，即使不在容器里面
  void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
  //判断指定的Bean是否有资格作为自动装配的候选者
  boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException;
  //返回注册的Bean定义(这个比较常用)  它可以拿到单独的某个Bean定义信息
  // ListableBeanFactory都是批量的返回
  BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  Iterator<String> getBeanNamesIterator();
  // 清理元数据的缓存
  void clearMetadataCache();
  //暂时冻结所有的Bean配置
  void freezeConfiguration();
  boolean isConfigurationFrozen();
  // 这个厉害了：实例化当前所有的剩下的单实例Bean们
  void preInstantiateSingletons() throws BeansException;
}

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
  ... 实现了大部分的方法，其中最终的实现为getBean()/doGetBean()方法的实现，提供了模版。其实createBean抽象方法，还是子类去实现的
  ... isSingleton(String name) / isPrototype(String name) / containsBean(String name) 也能实现精准的判断了
  // ===其中，它自己提供了三个抽象方法，子类必要去实现的===
  // 效果同：ListableBeanFactory#containsBeanDefinition  实现类：DefaultListableBeanFactory
  protected abstract boolean containsBeanDefinition(String beanName);
  // 效果同：ConfigurableListableBeanFactory#getBeanDefinition  实现类：DefaultListableBeanFactory
  protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;
  // 创建Bean的复杂逻辑，子类去实现。(子类：AbstractAutowireCapableBeanFactory)
  protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException;
}

// 继承自抽象实现：AbstractBeanFactory 
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
  // 它有很多属性，我觉得还是很有意义的
  // Bean的实例化需要借助它，策略接口
  private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
  // 解析方法参数的名字
  @Nullable
  private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
  // 这两个保存的类型，是ignore on dependency check and autowire（字段装配时，如果在这里面的类型讲被忽略）
  // 使用：我们可以自己忽略类型：beanFactory.ignoreDependencyType(ArrayList.class); 比如在BeanFactoryPostProcessor 这里可以这么做
  // 他们有些区别：因为平时使用较少，却别这里就不详细介绍了
  // 总之，若你自己想忽略特定类型的自动注入的话，推荐使用ignoredDependencyTypes 
  private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();
  private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();
  ... 最重要的是实现了doCreateBean()的创建逻辑，然后执行队形的BeanPostProcessor
  ... applyPropertyValues()：这里做的大部分工作就是依赖的准备工作
  ... 然后对bean实例化、初始化、并完成了它的依赖注入入口(具体逻辑由子类DefaultListableBeanFactory具体去实现)
  ... 它实现了对Bean的实例化、populateBean()、以及initializeBean()，会对Bean进行注入等操作
  ... 当然也管理了一些ignoredDependencyTypes,忽略的依赖等等
}

// extends：相当于继承了抽象类所有的实现，并且是已经具有注入功能了（含有ListableBeanFactory、ConfigurableListableBeanFactory的所有接口）
// implements：直接实现ConfigurableListableBeanFactory，表示它具有了批量处理Bean、配置Bean等等功能
// BeanDefinitionRegistry：该接口目前还仅有这个类实现（它父接口为：AliasRegistry ）
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
    implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
}

public interface BeanDefinitionRegistry extends AliasRegistry {
  // 注册一个Bean定义信息（下面的方法都非常的简单，就不一一介绍了）
  void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;
  void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
  boolean containsBeanDefinition(String beanName);
  String[] getBeanDefinitionNames();
  int getBeanDefinitionCount();
  boolean isBeanNameInUse(String beanName);
// 需要注意的是：这里面有写方法和ListableBeanFactory接口里定义的三个关于Bean定义的方法一样的：
//getBeanDefinitionNames/getBeanDefinitionCount等等
}