Spring源码系列（六）——容器的刷新（下）

https://blog.csdn.net/zxd1435513775/article/details/120886583?spm=1001.2014.3001.5501

Spring源码系列（三）——容器的刷新（上）

在上面这篇文章中，我们分析了到了refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory)这个方法，那么下面接着来分析后面的方法。

我们知道，当程序执行完invokeBeanFactoryPostProcessors(beanFactory)这个方法是，Spring工厂的创建工作已经完成了。符合条件的类都已经转为为BeanDefinition了，但是呢，这些BeanDefinition都还没有创建，下面断点到此代码，看Spring工厂里面的具体情况。

再次强调一下这几个变量的意思：

beanDefinitionMap：存放Spring容器中的所有的BeanDefinition

beanDefinitionNames：存放Spring容器中的所有的beanName

singletonObjects：存放Spring容器中已经完成实例化的对象，这个集合里面存在的变量表示已经完成了实例化

一、容器的刷新

下面来看一下这个名声在外的refresh()方法：

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        
        // 准备工作，包括设置启动时间，是否激活标识位，初始化属性源(property source)配置
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 返回一个factory 为什么需要返回一个工厂？ 因为要对工厂进行初始化
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 准备工厂
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 这个方法在当前版本的spring是没用任何代码的，可能spring期待在后面的版本中去扩展吧
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // 调用BeanFactoryPostProcessors的后置处理器
            invokeBeanFactoryPostProcessors(beanFactory);

            //-------------------到此spring工厂完成创建工作--------------------------

            // Register bean processors that intercept bean creation.
            // 注册BeanPostProcessor后置处理器
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化应用事件广播器
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            onRefresh();

            // Check for listener beans and register them.
            registerListeners();

            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        } catch (BeansException ex) {

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        } finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

1. registerBeanPostProcessors(beanFactory)

此方法是向Spring容器中添加BeanPostProcessor，Spring容器中有一个集合用户存放这个BeanPostProcessor。下面看下断点调试图：

此方法执行前

此方法执行后：

下面来分析这个方法

此处提醒一下，在AnnotationConfigApplicationContext()构造方法中创建AnnotatedBeanDefinitionReader()读取器时，Spring自己往容器中添加了6个类，如下：

// 实现 BeanDefinitionRegistryPostProcessor,PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware
org.springframework.context.annotation.internalConfigurationAnnotationProcessor

// 继承 InstantiationAwareBeanPostProcessorAdapter(实现BeanPostProcessor)
// 实现 BeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
org.springframework.context.annotation.internalAutowiredAnnotationProcessor

// 继承 InstantiationAwareBeanPostProcessorAdapter(实现BeanPostProcessor)
// 实现 MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
org.springframework.context.annotation.internalRequiredAnnotationProcessor

// 继承 InitDestroyAnnotationBeanPostProcessor
// 实现 InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable
org.springframework.context.annotation.internalCommonAnnotationProcessor

// 实现 SmartInitializingSingleton, ApplicationContextAware
org.springframework.context.event.internalEventListenerProcessor

// 实现 EventListenerFactory, Ordered
org.springframework.context.event.internalEventListenerFactory

public static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    // 从beanDefinitionNames集合中拿到所有类型是BeanPostProcessor名字
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
BeanPostProcessor集合中
    // 新建一个BeanPostProcessorChecker，并放入到beanPostProcessor集合中
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 将实现prioritordered、Ordered和剩余的，BeanPostProcessors分开
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 实现PriorityOrdered接口的BeanPostProcessor
            // 根据名字去容器中拿对应的BeanPostProcessor
            // 此处需要注意的是getBean()方法是从容器中拿，拿不到就创建
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 实现Ordered接口的BeanPostProcessor
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    // 排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 注册
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // 处理实现Ordered接口的BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // Now, register all regular BeanPostProcessors.
    // 处理既没有实现PriorityOrdered接口也没有实现Ordered接口的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // Finally, re-register all internal BeanPostProcessors.
    // internalPostProcessors里面存放的是实现MergedBeanDefinitionPostProcessor接口的类
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // 在前面的方法prepareBeanFactory()中，已经添加过这个ApplicationListenerDetector后置处理器
    // 所以此处不会再进行添加
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

注意：

在getBean()方法去容器中拿BeanPostProcessor的时候，如果容器中没有，则就去创建，所以此处方法执行完所有的BeanPostProcessor都已经实例化了。

2. initMessageSource()

初始化消息源

protected void initMessageSource() {
    // 获取Spring工厂
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    
    //查找是否包含了名为messageSource的bean，如果没有，创建一个默认的
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);

        //判断是否有父类且是一个分层级的messageSource，如果是将父容器的的messageSource设置到里边
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
    } else {
        // Use empty MessageSource to be able to accept getMessage calls.
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    }
}

3. initApplicationEventMulticaster()

初始化应用事件广播器，忽略

4. onRefresh()

此方法没有任何实现，留给需要扩展的子类，看注解

protected void onRefresh() throws BeansException {
    // For subclasses: do nothing by default.
}

5. registerListeners()

注册监听器，忽略

6. finishBeanFactoryInitialization(beanFactory)

实例化所有剩余的(非懒加载)单例对象，非常重要！！！！此处要将扫描出来的并转化成BeanDefinition的类进行实例化，单独成篇。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 为Spring容器初始化转换服务。
    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));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader(null);

    beanFactory.freezeConfiguration();

    // 上面的方法都不重要，下面这行很重要，在此处实例化所有的单例非懒加载对象
    // BeanDefinition的实例化
    beanFactory.preInstantiateSingletons();
}

下面来看下这个preInstantiateSingletons()方法源码

public void preInstantiateSingletons() throws BeansException {

    // beanDefinitionNames集合存放的是所有bean的名字
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 循环集合
    // 触发所有非延迟加载单例bean的初始化，主要步骤为调用getBean()
    for (String beanName : beanNames) {
        // 合并父BeanDefinition，为什么需要合并呢？想想在xml配置的时候，是不是有个parent属性？
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 如果BeanDefinition不是抽象的，不是懒加载的，是单列的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 如果是FactoryBean
            if (isFactoryBean(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<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                    } else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            } else {
                // 很重要，初始化！！！
                getBean(beanName);
            }
        }
    }

    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            } else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

这地方又分析到了getBean()这个方法，所有Bean的实例化就是在这个方法中完成的，下面重点来分析一下。

7. finishRefresh()

完成此上下文的刷新，略

二、说明

此部分的核心就是第六小点的方法，finishBeanFactoryInitialization(beanFactory)此方法是完成Bean的创建，非常复杂。