ApplicationContext 和 BeanFactory 是一对默契的搭档:
– ApplicationContext 负责翻译用户需求 (将目标 spring 配置转换为 BeanDefinition), BeanFactory 负责实现需求 (根据 BeanDefinition 的需求描述生产具体的 spring bean);
– ApplicationContext 像个经理对外提供服务 (getBean(name) 方法), 底层依赖 BeanFactory 这个打工人真正干活 (createBean(name, mbd, args) 方法);
可见 BeanFactory 是整个 spring 框架的中流砥柱、技术骨干, 因此 BeanFactory 是 spring 学习过程中最重要的知识点之一;

BeanFactory 的作用

关于 BeanFactory 的定位及作用, 以下是从 spring 源码中节选出的注释:

This interface is implemented by objects that hold a number of bean definitions, each uniquely identified by a String name. Depending on the bean definition, the factory will return either an independent instance of a contained object (the Prototype design pattern), or a single shared instance (a superior alternative to the Singleton design pattern, in which the instance is a singleton in the scope of the factory). Which type of instance will be returned depends on the bean factory configuration

用一句话可概括为: BeanFactory 负责翻译 BeanDefinition 并生产出最终的 spring bean:

BeanFactory 的调用时机和过程

BeanFactory 的体系结构

DefaultListableBeanFactory 是 spring 中最经典的 BeanFactory, 无论是 xml 配置还是注解注入, 默认使用的 BeanFactory 都是 DefaultListableBeanFactory;
我们以其为例看下它的类继承结构图:

BeanFactory 的继承结构图

根据上图我们可以先快速梳理一下 DefaultListableBeanFactory 的继承/实现结构:
蓝色箭头 (继承) 的链路:

• 直接继承了 AbstractAutowireCapableBeanFactory: 表明其支持 spring bean 的自动装配;
• 继承源头是 DefaultSingletonBeanRegistry (SimpleAliasRegistry): 表明其是一个单例 spring bean 的注册中心;

绿色箭头 (实现) 的链路:

• 直接实现了 BeanDefinitionRegistry 接口: 表明其是一个 BeanDefinition 的注册中心;
• 间接实现了 ListableBeanFactory 接口: 表明其可以按条件查找、遍历注册在其中的 spring bean 子集;
• 间接实现了 HierarchicalBeanFactory 接口: 表明其支持层级关系的父子容器;
• 间接实现了 ConfigurableBeanFactory 接口: 表明其支持精细化的 bean 特性管理, 包括 bean 的作用域设置 (singleton / prototype)、类加载器设置、设置别名、设置 dependentBeans 等等高级能力;

 
下面我将详细分析上述提及的各个类 (接口) 的能力:

特征能力

个性化能力: ConfigurableBeanFactory

检索遍历能力: ListableBeanFactory

深度个性化能力: ConfiurableListableBeanFactory

自动装配能力: AutowireCapableBeanFactory

AutowireCapableBeanFactory 接口定义了自动装配能力的规范, 主要包括典型通用能力和精细控制能力:

典型通用能力:

Typical methods for creating and populating external bean instances

• createBean(beanClass): 创建完整 spring bean (实例化、自动装配、初始化) 的能力;
• autowireBean(existingBean): 自动装配 (依赖注入) 一个已创建的 bean 实例;
• configureBean(existingBean, beanName): 自动装配并初始化一个已创建的 bean 实例;

可见以上三个方法的能力覆盖范围: createBean > configureBean > autowireBean;
 
精细控制能力:

Specialized methods for fine-grained control over the bean lifecycle

• 指定自动装配的形式 (by name or by type):

  • createBean(beanClass, autowireMode, dependencyCheck);
  • autowire(beanClass, autowireMode, dependencyCheck);
  • autowireBeanProperties(existingBean, autowireMode, dependencyCheck);

• 独立执行配置的 BeanPostProcessors:

  • applyBeanPostProcessorsBeforeInitialization(existingBean, beanName);
  • applyBeanPostProcessorsAfterInitialization(existingBean, beanName);

• applyBeanPropertyValues:

• initializeBean(existingBean, beanName): 仅初始化一个已创建的 bean 实例;

• destroyBean: 销毁指定的 spring bean;

注册中心能力

SingletonBeanRegistry

BeanDefinitionRegistry

主干流程

框架模板: AbstractBeanFactory

AbstractBeanFactory 主要实现了 BeanFactory 中最核心的几个「获取 bean」的方法:

1
2
3

Object getBean(String name);
<T> T getBean(String name, Class<T> requiredType);
Object getBean(String name, Object... args);

以上三个方法最终都是统一通过调用 doGetBean 方法实现的:

1
2

// AbstractBeanFactory.java
<T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) {...}

doGetBean 方法的主要流程如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

AbstractBeanFactory:
    doGetBean(beanName)
        // 尝试从缓存中获取
        -> sharedInstance = getSingleton(beanName)
        // 有缓存, 直接返回
        -> if (sharedInstance != null): return getObjectForBeanInstance(sharedInstance...)
        // 原型模式下的循环依赖检测
        -> if (isPrototypeCurrentlyInCreation(beanName)): throw exception
        // 若当前 beanFactory 不存在 beanDefinition, 尝试从 parentBeanFactory 中 getBean
        -> if (getParentBeanFactory() != null && !containsBeanDefinition(beanName)): return parentBeanFactory.getBean(beanName)
        -> mbd = getMergedLocalBeanDefinition(beanName)
        // 优先处理所有配置了 @DependsOn 的 beans
        -> foreach depend in mbd.getDependsOn():
            -> registerDependentBean(depend, beanName)
            // 对每个需要依赖的 bean 递归调用 getBean
            -> getBean(depend)

        // 处理单例 bean 的分支流程
        -> if (mbd.isSingleton()):
            DefaultSingletonBeanRegistry:
                // singletonObjectFactory 用于构造单例对象填充进一级缓存
                -> getSingleton(beanName, singletonObjectFactory: () -> {
                        /***** 抽象方法, 交给子类实现 *****/
                        -> beanInstance = createBean(beanName, mbd, ...)
                    })

        // 处理原型 bean 的分支流程
        ->  else if (mbd.isPrototype()):
            /***** 抽象方法, 交给子类实现 *****/
            -> beanInstance = createBean(beanName, mbd, ...)
        
        // 其他 scope bean 的处理分支
        -> else:
            -> scopeName = mbd.getScope()
            -> scope = scopes.get(scopeName)
            -> beanInstance = scope.get(beanName, () -> {
                /***** 抽象方法, 交给子类实现 *****/
                return createBean(beanName, mbd, ...)
            })
        
        -> return beanInstance

整套 doGetBean 框架定义好了如何获取 spring bean 的统一模板:

1. 当缓存存在, 直接获取;
2. 如果 scope == prototype, 先做循环依赖检测;
3. 如果当前 beanFactory 不存在目标 beanDefinition, 尝试从 parentBeanFactory 中获取 (递归调用 getBean);
4. 优先加载由 @DependsOn 申明的依赖 bean (递归调用 getBean);
5. 根据 scope 创建目标 bean;

可以看到, AbstractBeanFactory 留白了一个用于真正实际创建 bean 的 createBean 方法:

1
2

// AbstractBeanFactory.java
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args);

至于具体要如何创建、创建出一个什么样的 bean, 完全交由子类去决定;

核心实现: AbstractAutowireCapableBeanFactory

AbstractAutowireCapableBeanFactory 是 AbstractBeanFactory 的唯一抽象子类, 它实现了 (并且是唯一的实现) AbstractBeanFactory 留白的 createBean(String, RootBeanDefinition, Object[]) 方法, 并对该方法做了如下注释:

Central method of this class: creates a bean instance, populates the bean instance, applies post-processors, etc.

作为该类最核心的方法, 它用自动装配的语义实现了 spring bean 的创建流程 (实例化、依赖注入、后置处理与初始化一条龙服务), 这也是 spring IoC 的精髓所在;
AbstractAutowireCapableBeanFactory#createBean 方法的主要流程如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

AbstractAutowireCapableBeanFactory:
    -> createBean(beanName, mbd, ...)
        -> doCreateBean(beanName, mbd, ...)
            // 实例化
            -> instanceWrapper = createBeanInstance(beanName, mbd, ...) -> instantiateBean(beanName, mbd)
            // 执行增强 mergedBeanDefinition 的后置处理器
            -> applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
            /**** earlyBeanRefFactory 用于构造对象工厂填充进三级缓存 ****/
            -> addSingletonFactory(beanName, earlyBeanRefFactory: () -> getEarlyBeanReference(beanName, mbd, bean)):
                -> if (!singletonObjects.containsKey(beanName))
                    -> singletonFactories.put(beanName, earlyBeanReferenceFactory)
            // 依赖注入
            -> populateBean(beanName, mbd, instanceWrapper)
            // 初始化
            -> initializeBean(beanName, instanceWrapper.getWrappedInstance(), mbd)
            ......

另外 AbstractAutowireCapableBeanFactory 通过复用 createBean 中涉及的子模块, 实现了 AutowireCapableBeanFactory 接口, 具备了细粒度控制 spring bean 生命周期的能力:

集大成者

DefaultListableBeanFactory

参考资料

• 介绍一下Spring的底层工厂体系