Spring IOC容器初始化过程及其原理（源码层面）

Spring大家族在Java技术生态体系中占有重要地位，其中Spring更是其中的佼佼者。它极大的简化了我们的代码开发量，提高我们的工作效率。

其中Spring两大特性中的IOC特性是至关重要的。今天来从底层看一看Spring的容器的初始化过程。算是我的学习笔记，也希望能对你有所帮助！

（如果有不懂IOC的小伙伴们可以去看一看我前面写的文章传送门在此）。

在开始之前，先思考几个问题。

@Component,@Service,@Controller,@Repository@Bean等注解怎么实现的？
@Autowired,@Resource 是怎么自动装配的？
@ComponentScan 为什么就可以扫描注册Bean

对此我在其他博客看到一张图，感觉很生动形象。

IOC 容器示意图

Spring IOC ：

Bean定义的定位,Bean 可以定义在XML中，或者一个注解，或者其他形式。这些都被用Resource来定位, 读取Resource获取BeanDefinition 注册到 Bean定义注册表中。

第一次向容器getBean操作会触发Bean的创建过程,实列化一个Bean时 ,根据BeanDefinition中类信息等实列化Bean.

将实列化的Bean放到单列Bean缓存内。

此后再次获取向容器getBean就会从缓存中获取。

OK，下面来看容器的初始化方法。

源码如下：

public void refresh() throws BeansException, IllegalStateException {
//同步代码块 。
        synchronized (this.startupShutdownMonitor) {
            // 准备刷新.
            prepareRefresh();
            // Tell the subclass to refresh the internal bean 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.
                postProcessBeanFactory(beanFactory);
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
                // Register bean processors that intercept bean creation.
                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) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + 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. prepareRefresh 准备刷新

设置启动时间,设计容器激活标志(active=true)

初始化 properties 资源

验证必须存在的properties(validateRequiredProperties)

初始earlyApplicationEnvents.用于收集已经产生的ApplicationEnvents.

2.obtainFreshBeanFactory 获取容器

调用子类的refeshBeanFactory(),SpringBoot中采用默认的实现，设置BeanFactory的SerializationId,设置refreshed标志为true。

获取BeanFactory

XmlWebApplicationContext ，AnnotationConfigApplicationContext 会在这一步加载BeanDefinition

3.prepareBeanFactory 为了接下来使用BeanFactory 做准备

为BeanFactory 做些标准的设置

为内部的BeanFactory设置类加载器

设置表达式解析器，属性编辑器。

注册BeanPostProcessor(ApplicationContextAwareProcessor,ApplicationListenerDetector),

ApplicationContextAwareProcessor:对Spring 中各种Aware接口的支持,在初始化Bean前，调用Bean实现的Aware接口方法。

ApplicationListenerDetector：用于收集实现了ApplicationListener接口的Bean

4.注册指定的依赖类型和对应的value,

例如:beanFactory.registerResolvableDependency(ResourceLoader.class, this);那么在类中自动注入ResourceLoader类型的对象，就会拿到当前IOC容器。

5.注入一些其它信息的bean，比如environment、systemProperties等

4.postProcessBeanFactory 后处理BeanFactory

用于在BeanFactory 完成标准的初始化之后修改BeanFactory。不同容器根据自己的需求添加特殊的后置处理器，

EmbeddedWebApplicationContext 容器在这里添加了对ServletContextAware支持的Bean后置处理器(WebApplicationContextServletContextAwareProcessor)。

5.invokeBeanFactoryPostProcessors 执行BeanFactory后置处理器。

实例化并且执行所有已经注册到BeanFactory中的 BeanFactoryPostProcessor。支持按照Order排序。

1.执行逻辑
调用PostProcessorRegistrationDelegate的静态方法invokeBeanFactoryPostProcessors,
执行顺序：

1.执行ApplicationContext初始化器注册的BeanDefinitionRegistryPostProcessor类型的处理器
2.执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor。
3.执行实现了Ordered的BeanDefinitionRegistryPostProcessor
4.执行 所有后置处理器的 BeanFactoryPostProcessor 的接口方法
5.获取所有的BeanFactoryPostProcessor,排除已经执行过得后置处理器。
6.按照2-4的顺序 执行所有未执行的BeanFactoryPostProcessor。

2.介绍BeanFactoryPostProcessor 接口

针对BeanFactory 的处理,允许使用者修改容器中的bean definitions,例如：
ServletComponentRegisteringPostProcessor提供对@WebFilter,@WebServlet,@WebListener注解的扫描，并注册到容器中。
ConfigurationClassPostProcessor 对所有的@Configuration类进行动态代理的增强。
注意使用时不能对任何BeanDefinition 进行实列化操作。

3.介绍BeanDefinitionRegistryPostProcessor 接口

继承自BeanFactoryPostProcessor，针对BeanDefinitionRegistry的后置处理器,会先于BeanFactoryPostProcessor 执行。

4.ConfigurationClassPostProcessor

ConfigurationClassPostProcessor后置处理器实现了 PriorityOrdered接口，优先级最高的后置处理器，在SpringBoot自动配置的实现中起到举足轻重的作用。是自动配置功能的驱动着,如果没有他那些神奇的自动配置注解都不在起作用,对@Configuration,@Bean,@ComponentScan,@Import,@ImportResource,@PropertySource注解解析。


1. 处理PropertySources 注解
加载property资源
2. 处理ComponentScans和ComponentScan注解
扫描指定包下所有@Component注解。包括@Service，@Controller,@Repository,@Configuration,@ManagedBean
3. 处理@Import注解类

解析所有包含@Import注解。spring中@Enable****注解的实现依赖。@Import的value 有两种类型的Class.
3.1 ImportSelector 导入选择器。
执行非DeferredImportSelector接口的，收集配置类。
收集DeferredImportSelector接口的实现。稍后执行。
3.2 ImportBeanDefinitionRegistrar 导入类定义注册者
收集ImportBeanDefinitionRegistrar对象。
3.3 如果不是上面两种类型 就会被当作普通的configuration 类 注册到容器。
例如@EnableScheduling
4. 处理ImportResource注解
收集@ImportResource中指定的配置文件信息。
5. 收集@Bean注解的方法

6. 处理接口默认方法
7. 处理父类
父类className 不是"java"开头，并且是未处理过的类型。获取父类循环1-7。
8. 处理3.1中收集的DeferredImportSelector。
9.利用ConfigurationClassBeanDefinitionReader 处理每个Configuration类的@Bean和第4步收集的资源和3.2中收集的注册者。

6.registerBeanPostProcessors 注册bean后置处理器

委托给PostProcessorRegistrationDelegate的静态方法registerBeanPostProcessors执行

1.1 按照 PriorityOrdered，Ordered,普通，MergedBeanDefinitionPostProcessor 添加到 beanFactory 的beanPostProcessors属性中。最后添加ApplicationListenerDetector。

BeanPostProcessors 接口
该接口在Bean的实列话过程中被调用,在对一个对象进行初始化前后被调用。

例如：实现了 EnvironmentAware,EmbeddedValueResolverAware，ResourceLoaderAware，ApplicationContextAware等Aware就是这个时候被执行的。

MergedBeanDefinitionPostProcessor 接口

 该接口继承了BeanPostProcessors接口, 会在 bean 实列化之后属性注入前执行。例如对@Autowired @Resource @Value 注解的解析

7.initMessageSource

在Spring容器中初始化一些国际化相关的属性。

8.nitApplicationEventMulticaster

在容器中初始化Application事件广播器

9.onRefresh

onRefresh是一个模板方法，留给子类容器扩赞，不同的容器做不同的事情。

例如：容器AnnotationConfigEmbeddedWebApplicationContext中会调用createEmbeddedServletContainer方法去创建内置的Servlet容器。
EmbeddedServletContainerAutoConfiguration 类中定义了 Spring boot 支持的三种 Servlet容器。
目前SpringBoot只支持3种内置的Servlet容器：

Tomcat
Jetty
Undertow

10.registerListeners

将所有的 ApplicationListener 实现类注册到 ApplicationEventMulticaster中,觉得是观察者模式。

把已经产生的事件广播出去。

11.finishBeanFactoryInitialization

实列化所有非懒加载的类。

12.finishRefresh

完成容器的初始化过程,发布相应事件。
启动容器的声明周期处理器。管理容器声明周期。
发布 ContextRefreshedEvent事件。
启动内嵌的Servlet容器。
发布容器启动事件。

综上，Spring容器的初始化大致可以分为12个大部分。

这里我并没有把每个方法的源码调出来。

一是因为确实逻辑非常复杂，难以理解。

二是确实也记忆不住。所以在此我仅仅写出来了初始化过程中的具体步骤与相应的操作。虽然我们不可能永远对源码过程记忆的丝毫不差，但是在探索源码的过程中对我们自身的相关能力确实有很大帮助。

下面我列出初始化过程中的更详细步骤，仅供参考！

Spring容器的refresh()【创建刷新】;
1、prepareRefresh()刷新前的预处理;
   1）、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法；
   2）、getEnvironment().validateRequiredProperties();检验属性的合法等
   3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；
2、obtainFreshBeanFactory();获取BeanFactory；
   1）、refreshBeanFactory();刷新【创建】BeanFactory；
           创建了一个this.beanFactory = new DefaultListableBeanFactory();
           设置id；
   2）、getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
   3）、将创建的BeanFactory【DefaultListableBeanFactory】返回；
3、prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；
   1）、设置BeanFactory的类加载器、支持表达式解析器...
   2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
   3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
   4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
           BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
   5）、添加BeanPostProcessor【ApplicationListenerDetector】
   6）、添加编译时的AspectJ；
   7）、给BeanFactory中注册一些能用的组件；
       environment【ConfigurableEnvironment】、
       systemProperties【Map<String, Object>】、
       systemEnvironment【Map<String, Object>】
4、postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作；
   1）、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
======================以上是BeanFactory的创建及预准备工作==================================
5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法；
   BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
   两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
   1）、执行BeanFactoryPostProcessor的方法；
       先执行BeanDefinitionRegistryPostProcessor
       1）、获取所有的BeanDefinitionRegistryPostProcessor；
       2）、看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
           postProcessor.postProcessBeanDefinitionRegistry(registry)
       3）、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
           postProcessor.postProcessBeanDefinitionRegistry(registry)
       4）、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
           postProcessor.postProcessBeanDefinitionRegistry(registry)


       再执行BeanFactoryPostProcessor的方法
       1）、获取所有的BeanFactoryPostProcessor
       2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
           postProcessor.postProcessBeanFactory()
       3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
           postProcessor.postProcessBeanFactory()
       4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
           postProcessor.postProcessBeanFactory()
6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器）【 intercept bean creation】
       不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的
       BeanPostProcessor、
       DestructionAwareBeanPostProcessor、
       InstantiationAwareBeanPostProcessor、
       SmartInstantiationAwareBeanPostProcessor、
       MergedBeanDefinitionPostProcessor【internalPostProcessors】、

       1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
       2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
           把每一个BeanPostProcessor；添加到BeanFactory中
           beanFactory.addBeanPostProcessor(postProcessor);
       3）、再注册Ordered接口的
       4）、最后注册没有实现任何优先级接口的
       5）、最终注册MergedBeanDefinitionPostProcessor；
       6）、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是
           applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7、initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
       1）、获取BeanFactory
       2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
           如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
               MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
       3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
           beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
           MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();初始化事件派发器；
       1）、获取BeanFactory
       2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
       3）、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
       4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();留给子容器（子类）
       1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；
       1、从容器中拿到所有的ApplicationListener
       2、将每个监听器添加到事件派发器中；
           getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
       3、派发之前步骤产生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；
   1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
       1）、获取容器中的所有Bean，依次进行初始化和创建对象
       2）、获取Bean的定义信息；RootBeanDefinition
       3）、Bean不是抽象的，是单实例的，是懒加载；
           1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
           2）、不是工厂Bean。利用getBean(beanName);创建对象
               0、getBean(beanName)； ioc.getBean();
               1、doGetBean(name, null, null, false);
               2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
                   从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的
               3、缓存中获取不到，开始Bean的创建对象流程；
               4、标记当前bean已经被创建
               5、获取Bean的定义信息；
               6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】
               7、启动单实例Bean的创建流程；
                   1）、createBean(beanName, mbd, args);
                   2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；
                       【InstantiationAwareBeanPostProcessor】：提前执行；
                       先触发：postProcessBeforeInstantiation()；
                       如果有返回值：触发postProcessAfterInitialization()；
                   3）、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4）
                   4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
                       1）、【创建Bean实例】；createBeanInstance(beanName, mbd, args);
                          利用工厂方法或者对象的构造器创建出Bean实例；
                       2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                          调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
                       3）、【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
                          赋值之前：
                          1）、拿到InstantiationAwareBeanPostProcessor后置处理器；
                              postProcessAfterInstantiation()；
                          2）、拿到InstantiationAwareBeanPostProcessor后置处理器；
                              postProcessPropertyValues()；
                          =====赋值之前：===
                          3）、应用Bean属性的值；为属性利用setter方法等进行赋值；
                              applyPropertyValues(beanName, mbd, bw, pvs);
                       4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
                          1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
                              BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
                          2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                              BeanPostProcessor.postProcessBeforeInitialization（）;
                          3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
                              1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
                              2）、是否自定义初始化方法；
                          4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
                              BeanPostProcessor.postProcessAfterInitialization()；
                       5）、注册Bean的销毁方法；
                   5）、将创建的Bean添加到缓存中singletonObjects；
               ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；
       所有Bean都利用getBean创建完成以后；
           检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；
       1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
           默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
           加入到容器；

           写一个LifecycleProcessor的实现类，可以在BeanFactory
               void onRefresh();
               void onClose();
       2）、   getLifecycleProcessor().onRefresh();
           拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
       3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
       4）、liveBeansView.registerApplicationContext(this)

    ======总结=======

   1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
       1）、xml注册bean；<bean>
       2）、注解注册Bean；@Service、@Component、@Bean、xxx
   2）、Spring容器会合适的时机创建这些Bean
       1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
       2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
   3）、后置处理器；BeanPostProcessor
       1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
           AutowiredAnnotationBeanPostProcessor:处理自动注入
           AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
           xxx....
           增强的功能注解：
           AsyncAnnotationBeanPostProcessor
           ....
   4）、事件驱动模型；
       ApplicationListener；事件监听；
       ApplicationEventMulticaster；事件派发：