Spring源码之finishBeanFactoryInitialization()

finishBeanFactoryInitialization(beanFactory) 是 Spring 框架中 AbstractApplicationContext 类的一个方法，它负责完成 BeanFactory 的初始化，包括实例化所有剩余的非延迟单例 Bean。

finishBeanFactoryInitialization 代码

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化剩余的单例（非懒加载）Bean。
    beanFactory.preInstantiateSingletons();
}

---

针对其中的beanFactory.preInstantiateSingletons()方法，在进行代码解析

beanFactory.preInstantiateSingletons 方法代码

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

    // 获取所有 BeanDefinition 的名称
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 循环所有的 BeanDefinition 名称，实例化所有非懒加载的单例 Bean。
    for (String beanName : beanNames) {
    	// 获取对应bean的BeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 条件判断，抽象，单例，非懒加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        	//判断是否实现了FactoryBean接口
            if (isFactoryBean(beanName)) {
            	//根据&+beanName来获取具体的对象
                FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                        ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext());
                } else {
                    isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) {
                	//如果beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
                    getBean(beanName);
                }
            } else {
            	// 如果beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
            	// 这里就是循环依赖/三级缓存开始的地方
                getBean(beanName);
            }
        }
    }

    // 遍历 Bean 工厂中的所有 bean，并初始化那些实现了 SmartInitializingSingleton 接口的单例 bean
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            } else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

详细讲解

1. finishBeanFactoryInitialization(beanFactory)：

   • 这个方法的主要功能是完成 Bean 工厂的初始化工作。
   • 方法中调用了 preInstantiateSingletons 来实例化所有剩余的单例 Bean。

2. preInstantiateSingletons()：

   • 该方法遍历所有的 BeanDefinition 名称，并实例化所有非懒加载的单例 Bean。
   • 如果 Bean 是 FactoryBean，则先获取 FactoryBean 的实例并判断是否需要提前实例化。
   • 实例化所有非懒加载的单例 Bean。
   • 初始化那些实现了 SmartInitializingSingleton 接口的单例 Bean，调用其 afterSingletonsInstantiated 方法。

剩余的 Bean

在 finishBeanFactoryInitialization 中提到的“剩余的 Bean”指的是在应用上下文刷新过程中还没有被实例化的 Bean。具体来说：

1. 开发人员自己定义的 Bean：在配置文件中或者通过注解定义的 Bean。
2. 框架级别的 Bean：Spring 自己需要的一些内部 Bean，比如一些事件监听器、Aspect 切面等。

这些剩余的 Bean 主要是那些非懒加载的单例 Bean。懒加载的 Bean 不会在应用上下文初始化时实例化，而是在第一次使用时才会被实例化。

---

作用

finishBeanFactoryInitialization(beanFactory) 方法的作用是完成 BeanFactory 的初始化，确保所有的 Bean 实例被正确地创建、初始化并放置到容器中，以便应用程序能够正常运行。在这个方法中，会执行一系列的操作，包括实例化剩余的非延迟加载的单例 Bean、处理 Bean 的生命周期回调方法等。

内部关键步骤

1. 实例化非延迟加载的单例 Bean： 首先，方法会实例化所有非延迟加载的单例 Bean。这些 Bean 是在容器启动时就被预先实例化的，以保证它们在应用程序启动时就可用。

2. 提前暴露 Bean 的实例： 在实例化 Bean 的过程中，如果某个 Bean 实现了 SmartInitializingSingleton 接口，容器会在实例化完所有非延迟加载的单例 Bean 后，调用它们的 afterSingletonsInstantiated() 方法，以便它们在所有 Bean 都实例化完成后执行一些额外的初始化逻辑。

3. 处理 Bean 生命周期回调方法： 在实例化完成所有非延迟加载的单例 Bean 后，容器会依次调用这些 Bean 的生命周期回调方法，包括初始化方法（例如 @PostConstruct 标注的方法）、销毁方法（例如 @PreDestroy 标注的方法）等。

4. 注册 DisposableBean 的实现类： 在容器关闭时，需要销毁所有的单例 Bean。为了实现这个功能，容器会注册一个 DisposableBeanAdapter 的实例，用于管理单例 Bean 的销毁。

5. 注册 BeanPostProcessor 的实现类： 最后，容器会注册一些内部的 BeanPostProcessor 的实现类，用于处理各种类型的 Bean 后处理逻辑，例如属性注入、依赖解析等。

总结

finishBeanFactoryInitialization(beanFactory) 方法是 Spring 启动过程中的一个关键步骤，用于完成 BeanFactory 的初始化。在这个方法中，会执行一系列的操作，包括实例化非延迟加载的单例 Bean、处理 Bean 的生命周期回调方法等，以确保应用程序能够正常运行。