spring-beans包源码阅读-4-BeanFactory

欢迎光临我的个人博客：https://www.jelliclecat.cn/

前置

Spring阅读前言-里面讲了一些心路历程

spring-beans包源码阅读-2-BeanWrapper

spring-beans包源码阅读-3-BeanDefinition

终于到重点啦！由于BeanFactory太复杂了，这次我们会用单元测试调试跟踪源码。

一. BeanFactory和FactoryBean

先聊一聊BeanFactory和FactoryBean，期初我看源码的时候，看到这两个接口真是异常懵逼，他们的方法还很相似，都是获取一个Object。其实这两个接口八竿子打不着，九杆子能打着一点，这里就先讲一讲这两个接口各是干什么的。

1. BeanFactory

spring的总工厂，所有的bean的实例都保存在这个工厂中，并提供了各种不同的方法去获取各种的bean的实例。这个接口没啥好多说的，最核心的接口，等下我们会重点分析这个接口。

2. FactoryBean

从名字来看，首先这是一个Bean，然后这是一个工厂，其部分注释如下：

* If a bean implements this
* interface, it is used as a factory for an object to expose, not directly as a
* bean instance that will be exposed itself.
*
* 
NB: A bean that implements this interface cannot be used as a normal bean.
* A FactoryBean is defined in a bean style, but the object exposed for bean
* references ({@link #getObject()}) is always the object that it creates.

public interface FactoryBean {

  @Nullable
  T getObject() throws Exception;
  
  ...
}

FactoryBean才是真正的我们熟悉的"工厂方法模式"，其实命名为Factory会更好，但是在spring中，所有的实体都是Bean，一个Factory也不例外是一个Bean，所以就命名为了FactoryBean。实现了这个接口的类就是一个工厂类，里面需要实现获取具体对象的逻辑。

3. FactoryBean，工厂方法模式

这里不会详细介绍什么是工厂模式，因为在进行spring源码阅读的时候会假定已经掌握了各种常用的设计模式。

那么FactoryBean是怎么使用工厂方法模式的呢？

FactoryBean有一个直接实现类：AbstractFactoryBean，里面实现了T getObject() throws Exception方法：

  /**
   * Expose the singleton instance or create a new prototype instance.
   * @see #createInstance()
   * @see #getEarlySingletonInterfaces()
   */
  @Override
  public final T getObject() throws Exception {
    if (isSingleton()) {
      return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());
    }
    else {
      return createInstance();
    }
  }

  /**
   * Template method that subclasses must override to construct
   * the object returned by this factory.
   * 
Invoked on initialization of this FactoryBean in case of
   * a singleton; else, on each {@link #getObject()} call.
   * @return the object returned by this factory
   * @throws Exception if an exception occurred during object creation
   * @see #getObject()
   */
  protected abstract T createInstance() throws Exception;

最后扔给了一个模板方法createInstance()去完成具体的实例的创建工作，这就是一个标准的工厂模式。

二. How getBean() works.

BeanFactory接口的集大成者就是DefaultListableBeanFactory，整个Bean的实例化过程、实例化策略等等内容，都在DefaultListableBeanFactory以及其父类AbstractAutowireCapableBeanFactory和AbstractBeanFactory中，故也是我们研究的重点对象。

image

这个继承关系也是没谁了。。

1. AliasRegistry & SimpleAliasRegistry

bean可能有各种别名，这个接口用来提供给一个Bean添加一些别名，并提供根据某个别名查找一个Bean的逻辑。所有的别名引用关系保存在一个map中，取的时候是递归算法：

  // SimpleAliasRegistry.java
  /**
   * Transitively retrieve all aliases for the given name.
   * @param name the target name to find aliases for
   * @param result the resulting aliases list
   */
  private void retrieveAliases(String name, List result) {
    this.aliasMap.forEach((alias, registeredName) -> {
      if (registeredName.equals(name)) {
        result.add(alias);
        retrieveAliases(alias, result);
      }
    });
  }

2. DefaultSingletonBeanRegistry

提供了保存单例Bean的Map、Set等集合，不仅仅是完全体的Bean，也有正在创建中的Bean，以及Bean之间的依赖关系都在这里。常说的"spring容器"中的容器，按我的理解就是这个类了。看看这个类的属性，就知道它的功能：

    /** Cache of singleton objects: bean name to bean instance. */
    private final Map singletonObjects = new ConcurrentHashMap<>(256);

    /** Cache of singleton factories: bean name to ObjectFactory. */
    private final Map> singletonFactories = new HashMap<>(16);

    /** Cache of early singleton objects: bean name to bean instance. */
    private final Map earlySingletonObjects = new HashMap<>(16);

    /** Set of registered singletons, containing the bean names in registration order. */
    private final Set registeredSingletons = new LinkedHashSet<>(256);

    /** Names of beans that are currently in creation. */
    private final Set singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** Names of beans currently excluded from in creation checks. */
    private final Set inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** List of suppressed Exceptions, available for associating related causes. */
    @Nullable
    private Set suppressedExceptions;

    /** Flag that indicates whether we're currently within destroySingletons. */
    private boolean singletonsCurrentlyInDestruction = false;

    /** Disposable bean instances: bean name to disposable instance. */
    private final Map disposableBeans = new LinkedHashMap<>();

    /** Map between containing bean names: bean name to Set of bean names that the bean contains. */
    private final Map> containedBeanMap = new ConcurrentHashMap<>(16);

    /** Map between dependent bean names: bean name to Set of dependent bean names. */
    private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);

    /** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */
    private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

3. FactoryBeanRegistrySupport

这个类提供了对FactoryBean的支持，有一些bean不是直接创建的，而是通过FactoryBean工厂创建的，我们在上文讲过了FactoryBean。这个类的主要功能就是从FactoryBean中调用getObject方法拿到工厂创建出来的实例。

    /**
     * Obtain an object to expose from the given FactoryBean.
     * @param factory the FactoryBean instance
     * @param beanName the name of the bean
     * @return the object obtained from the FactoryBean
     * @throws BeanCreationException if FactoryBean object creation failed
     * @see org.springframework.beans.factory.FactoryBean#getObject()
     */
    private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName)
            throws BeanCreationException {

        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction