Day168.Spring容器创建过程 -Spring注解驱动

Spring注解驱动

Spring容器创建过程

spring核心逻辑AbstractApplicationContext的refresh()方法如下：

public void refresh() {
    synchronized (this.startupShutdownMonitor) {
        // 刷新前的预准备工作
        prepareRefresh();
        // 提取bean的配置信息并封装成BeanDefinition实例，然后将其添加到注册中心。注册中心是一个ConcurrentHashMap<String,BeanDefinition>类型，key为Bean的名字，value为BeanDefinition实例。
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
       //对beanFactory进行一些配置，注册一些BeanPostProcessor和一些特殊的Bean。
        prepareBeanFactory(beanFactory);
        
            //留给子类在BeanFactory准备工作完成后处理一些工作。
            postProcessBeanFactory(beanFactory);
           //调用 BeanFactory的后置处理器。
           invokeBeanFactoryPostProcessors(beanFactory);
           //注册Bean的后置处理器。
            registerBeanPostProcessors(beanFactory);
            //国际化相关功能
            initMessageSource();
            //初始化事件派发器；
            initApplicationEventMulticaster();
            // 提供给子容器类，供子容器去实例化其他的特殊的Bean
            onRefresh();
            // 处理容器中已有的ApplicationListener
            registerListeners();
            //初始化容器中剩余的单实例bean
            finishBeanFactoryInitialization(beanFactory);
            //最后一步
            finishRefresh();
        
        }
    }

一、BeanFactory预准备

Spring容器的refresh()【创建刷新】；
1、prepareRefresh();刷新前的预处理
    1）、initPropertySources();初始化一些属性设置；子类自定义个性化属性设置方法
    2）、getEnvironment().validateRequiredProperties();检验属性的合法性
    3）、this.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....等
    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创建并预准备完成以后做进一步设置

二、执行BeanFactoryPostProcessor

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、最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor
            postProcessor.postProcessBeanDefinitionRegistry(registry);

        再执行BeanFactoryPostProcessor的方法
        1、获取所有BeanFactoryPostProcessor；
        2、看先执行实现了PriorityOrdered优先级接口的获取所有BeanFactoryPostProcessor
            postProcessor.postProcessBeanFactory(beanFactory);
        3、再执行实现了Ordered顺序接口的BeanFactoryPostProcessor
            postProcessor.postProcessBeanFactory(beanFactory);
        4、最后执行没有实现任何优先级或者顺序接口的BeanFactoryPostProcessor
            postProcessor.postProcessBeanFactory(beanFactory);

三、注册BeanPostProcessor

6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor(Bean的后置处理器)【intercept bean creation，拦截bean创建过程】
    不同接口类型的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【internalPostProcessors】
    6）、注册一个ApplicationListenerDetector；来在bean创建完成后检查是否是ApplicationListener，
            如果是，applicationContext.addApplicationListener((ApplicationListener<?>) bean);添加到容器中

四、初始化MessageSource

7、initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）
    1）、获取BeanFactory
    2）、看容器中是否有id为messageSource的组件，类型为MessageSource的组件
            如果有，赋值给messageSource
            如果没有，自己创建一个DelegatingMessageSource；
                MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
    3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        自动注入获取后，调用getMessage();
        MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);

五、初始化事件派发器、监听器等

8、initApplicationEventMulticaster();初始化事件派发器
    1）获取BeanFactory；getBeanFactory();
    2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster
    3）、如果上一步没有自己配置事件派发器；它就创建一个SimpleApplicationEventMulticaster
    4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

9、onRefresh();留给子容器（子类）
    1）、子类重写这个方法，在容器刷新的时候可以自定义逻辑；

10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；
    1）、从容器中拿到所有的ApplicationListener组件
    2）、将每个监听器添加到事件派发器中；
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    3）、派发之前步骤产生的事件

六、创建Bean准备&Bean创建完成

11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean
    1）、beanFactory.preInstantiateSingletons();初始化剩下的单实例bean
        1、获取容器中的所有bean，依次进行初始化和创建对象
        2、获取bean的定义信息；RootBeanDefinition
        3、判断Bean不是抽象的，是单实例的，不是懒加载的
            1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
            2）、不是工厂Bean。利用getBean(beanName);创建对象
                getBean(beanName); ioc.getBean();
                --> doGetBean();
                --> 先获取缓存中保存的单实例Bean。如果能获取到，说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
            3）、缓存中拿不到，开始Bean的创建对象流程：
            4）、标记当前bean已经被创建
            5）、获取Bean定义信息；
            6）、【获取当前Bean依赖的其他Bean；如果有按照getBean()把依赖的Bean先创建出来；】
            7）、启动单实例Bean的创建流程；
                1、createBean(beanName,mbd,args);
                2、Object bean = resolverBeforeInstantiation(beanName,mbdToUse);让BeanPostProcessor先拦截返回代理对象
                    【InstantiationAwareBeanPostProcessor】： 提前执行；
                    先触发： postProcessBeforeInstantiation();
                    如果有返回值则，触发，postProcessAfterInstantiation();
                3、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4
                4、Object beanInstance = doCreateBean(beanName,mbdToUse,args);；创建bean
                    1）、【创建Bean实例】；createBeanInstance(beanName,mbd,args);
                        利用工厂方法或者对象的构造器创建出Bean实例
                    2）、applyMergedBeanDefinitionPostProcessor(mbd,beanType,beanName);
                        调用MergedBeanDefinitionPostProcessor的bdp.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；再返回

七、容器创建完成后

12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成
    1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
        默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有就new DefaultLifecycleProcessor();
        加入到容器中；
        写一个LifecycleProcessor的实现类，可以在BeanFactory的onRefresh()、onClose()；
    2）、getLifecycleProcessor().onRefresh();
        拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh();
    3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件
    4）、LiveBeansView.registerApplicationContext(this);

八、Spring源码总结

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

ioc容器的实质：

ioc容器的实质：
    ioc容器就是很多的Map；
    很多的Map里面保存了单实例Bean，环境信息等...所有的Map就构成了ioc容器，
    获取组件就是从这些Map中拿东西

感谢尚硅谷！！！