【Java】【系列篇】【Spring源码解析】【二】【整体】【Spring整体流程解析】

本篇文章的目的是希望对Spring运行有个整体上的了解，后面的文章都是基于此12大步骤
读完这篇文章，你可以了解到：
1.spring运行的大致流程，他在这个期间做了哪些事
2.xml方式和注解方式载入BeanDifinition的时机

一、Spring的运行的两个阶段

1.1、容器初始化阶段

容器启动阶段容器启动伊始,首先会通过某种途径加载Configuration MetaData
除了代码方式比较直接,在大部分情况下,容器需要依赖某些工具类(BeanDefinitionReader)对加载的Configuration MetaData进行解析和分析,并将分析后的信息编组为相应的BeanDefinition
最后把这些保存了bean定义必要信息的BeanDefinition,注册到相应的BeanDefinitionRegistry,这样容器启动工作就完成了。

1.2、Bean实例化阶段

经过第一阶段,现在所有的bean定义信息都通过BeanDefinition的方式注册到了BeanDefinitionRegistry中,当某个请求方通过容器的getBean方法明确地请求某个对象,或者因依赖关系容器需要隐式地调用getBean方法时,就会触发第二阶段的活动。
该阶段：

容器会首先检查所请求的对象之前是否已经初始化。
如果没有,则会根据注册的,BeanDefinition所提供的信息实例化被请求对象,并为其注入依赖。
如果该对象实现了某些回调接口,也会根据回调接口的要求来装配它。
当该对象装配完毕之后,容器会立即将其返回请求方使用。

如果说第一阶段只是根据图纸装配生产线的话,那么第二阶段就是使用装配好的生产线来生产具体的产品了。

二、Spring的refresh()方法解析<核心方法>

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 刷新前的预处理，设置上下文状态，获取属性，验证必要的属性等
        prepareRefresh();
        // 获取子类持有的BeanFactory；默认实现是DefaultListableBeanFactory 注意，此处是获取新的，销毁旧的，这就是刷新的意义
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // BeanFactory的预准备工作（BeanFactory进行一些设置，比如如classloader、el表达式解析器、BeanPostProcessor和XXXAware自动装配等）
        prepareBeanFactory(beanFactory);
        try {
            // 模板方法，允许在子类中对beanFactory进行后置处理，BeanFactory准备工作完成后进行的后置处理工作
            postProcessBeanFactory(beanFactory);
            // 实例化并调用所有注册的BeanFactory后置处理器（实现接口BeanFactoryPostProcessor的bean）
            invokeBeanFactoryPostProcessors(beanFactory);
            // 实例化和注册扩展了BeanPostProcessor的bean(Bean的后置处理器),注意：这里并没有执行，他会在bean创建的时候，被调用
            registerBeanPostProcessors(beanFactory);
            // 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
            initMessageSource();
            // 初始化事件派发器
            initApplicationEventMulticaster();
            // 模板方法，在容器刷新的时候可以自定义逻辑（子类自己去实现逻辑），不同的Spring容器做不同的事情，如创建Tomcat，Jetty等WEB服务器
            onRefresh();
            // 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，用于监听ApplicationEventMulticaster广播的ApplicationEvent事件
            registerListeners();
            // 实例化所有剩余的（非懒加载）单例Bean。（也就是我们自己定义的那些Bean们）
            finishBeanFactoryInitialization(beanFactory);
            // 完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
            finishRefresh();
        }
        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }
            // 如果刷新失败那么就会将已经创建好的单例Bean销毁掉
            destroyBeans();
            // 重置context的活动状态 告知是失败的
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            // 失败与否，都会重置Spring内核的缓存。因为可能不再需要metadata给单例Bean了。
            resetCommonCaches();
        }
    }
}

2.1、prepareRefresh()

该阶段主要设置启动时间和启动标识,可以被子类覆盖,但覆盖逻辑里面一定要调用super.prepareRefresh();容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等。

1）、initPropertySources() 这是扩展方法，由子类去实现，初始化一些属性设置;是子类自定义个性化的属性设置方法
2）、getEnvironment().validateRequiredProperties();检验属性的合法等
3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();初始化容器，用于装载早期的一些事件

2.2、obtainFreshBeanFactory()

这个方法就是创建BeanFactory，值得一说的是，使用xml方式和注解方式的执行期上下文在这里的实现有所不同，使用xml方式（比如ClassPathXmlApplicationContext）的执行期上下文是在这个方法里面加载进BeanDefinition的，而使用注解方式的执行器上下文（比如AnnotationConfigApplicationContext）则是通过ConfigurationClassPostProcessor这个BeanFactory后置处理器实现载入BeanDefinition的。

ClassPathXmlApplicationContext：

AnnotationConfigApplicationContext：

1）、refreshBeanFactory();刷新【创建】BeanFactory；
    xml方式：
        创建了一个this.beanFactory = new DefaultListableBeanFactory()
        设置id
        把当前旧容器的一些配置值复制给新容器
        加载所有的Bean配置信息
    注解方式：
        设置id
2）、getBeanFactory();
    返回BeanFactory对象；
3）、将创建的BeanFactory【DefaultListableBeanFactory】返回；

2.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>】

2.4、postProcessBeanFactory(beanFactory)

BeanFactory准备工作完成后进行的后置处理工作

1）、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置

2.5、invokeBeanFactoryPostProcessors(beanFactory)

执行BeanFactoryPostProcessor的方法（详细解析看【Java】【系列篇】【Spring源码解析】【四】【体系】【PostProcessors体系】这篇文章）

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()
注：在这里注解方式的执行期上下文就会通过ConfigurationClassPostProcessor后置处理器来载入BeanDefinition

2.6、registerBeanPostProcessors(beanFactory)

在这个方法里会注册BeanPostProcessor（（详细解析看【Java】【系列篇】【Spring源码解析】【四】【体系】【PostProcessors体系】这篇文章））

不同接口类型的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);

AutowiredAnnotationBeanPostProcessor(处理被@Autowired注解修饰的bean并注入)
RequiredAnnotationBeanPostProcessor(处理被@Required注解修饰的方法)
CommonAnnotationBeanPostProcessor(处理@PreDestroy、@PostConstruct、@Resource等多个注解的作用)等。

2.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);

2.8、initApplicationEventMulticaster()

1）、获取BeanFactory
2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
3）、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

2.9、onRefresh()

1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；

2.10、registerListeners()

1、从容器中拿到所有的ApplicationListener
2、将每个监听器添加到事件派发器中；
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3、派发之前步骤产生的事件；

2.11、finishBeanFactoryInitialization(beanFactory)

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()；

2.12、finishRefresh()

完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）

1）、clearResourceCaches();清除一些resourceCaches,如清除context级别的资源缓存，比如ASM的元数据
2）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
    默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
    加入到容器；
3）、	getLifecycleProcessor().onRefresh();
    拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
4）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
5）、liveBeansView.registerApplicationContext(this);

引用

《Spring揭秘》
https://blog.csdn.net/qq_34748010/article/details/124536317