Spring 源码学习 15：finishBeanFactoryInitialization（重点）

前言

可以说前面的都是准备工作，而接下来开始的才是重点，在这一步会完成 BeanFactory 的初始化，同时实例化单例 Bean。

具体怎么操作的，那就一起阅读源码吧！

不过在阅读源码之前，还是需要了解一些知识的。

1. 什么是 FactoryBean ？
2. FactoryBean 是如何使用的 ？
3. Bean 是如何初始化的？
4. 常说的循环依赖是怎么解决的？

什么是 FactoryBean ？

在官网的这篇文章《What's a FactoryBean?》中有相关解答，有兴趣的小伙伴可以看一下。

由内部使用的对象实现的接口，这些对象 BeanFactory 本身就是单个对象的工厂。如果 bean 实现此接口，则它将用作对象公开的工厂，而不是直接用作将自身公开的 bean 实例。

注意：实现此接口的 bean 不能用作普通 bean。 FactoryBean以 bean 样式定义，但是为 bean 引用（getObject()）公开的对象始终是它创建的对象。

FactoryBeans 可以支持单例和原型，并且可以按需延迟创建对象，也可以在启动时急于创建对象。

当生命一个 FactoryBean 时，会存在两个类型的 Bean，分别是 FactoryBean 本身，以及它需要创建的类型的 Bean。

下面是使用示例：

使用

1. PaidComponent

public class PaidComponent {

    public PaidComponent() {
        System.out.println("PaidComponent 无参构造被调用");
    }
}

2. PaidComponentFactoryBean

@Component
public class PaidComponentFactoryBean implements FactoryBean {

    @Override
    public PaidComponent getObject() throws Exception {

        System.out.println("PaidComponentFactoryBean 的 getObject 方法被调用");

        return new PaidComponent();
    }

    @Override
    public Class getObjectType() {
        return PaidComponent.class;
    }
    
}

3 Test

public class AnnotationConfigApplicationTest {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

        context.register(JavaConfig.class);


        context.refresh();


        System.out.println(context.getBean("paidComponentFactoryBean"));
        System.out.println(context.getBean("&paidComponentFactoryBean"));
        System.out.println(context.getBean(PaidComponent.class));

    }
}

可以看出注册了两个 Bean， 一个是 paidComponentFactoryBean ，另一个是 &paidComponentFactoryBean。

而直接获取 paidComponentFactoryBean 获取到的其实是 FactoryBean 的 getObject() 方法返回的类型。

finishBeanFactoryInitialization 源码

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    // 初始化类型转换器
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    // 主要用于注释属性值的解析
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    // 尽早初始化 LoadTimeWeaverAware Bean，以便尽早注册其转换器。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    // 停止使用临时的ClassLoader进行类型匹配。
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    // 设置 beanDefinition 元数据 不可以再修改
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 实例化单例 bean
    beanFactory.preInstantiateSingletons();
}

这里重点关注最后一行

beanFactory.preInstantiateSingletons();

preInstantiateSingletons

这块进入的是类 DefaultListableBeanFactory 类的源码。

public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 将 beanDefinitionNames 放到集合中
    List beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 遍历
    for (String beanName : beanNames) {
        // 获取 bd 信息, 因为可能 定义了 parentBeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 非抽象, 单例, 且不是懒加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 判断是否为 FactoryBean
            if (isFactoryBean(beanName)) {
                // FactoryBean 需要添加前缀 & ,通过 getBean(&beanName) 获取的是 FactoryBean 本身
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    FactoryBean factory = (FactoryBean) bean;
                    // 判断是否需要初始化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                                (PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    // 需要初始化
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    // 如果 Bean 实现了 SmartInitializingSingleton,
    // 在这里会统一调用 afterSingletonsInstantiated 方法
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                    .tag("beanName", beanName);
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction