spring容器的初始化（菜鸟笔记）

妖狐艹你老母 2024-02-19 21:23 48阅读 0赞

## spring容器的初始化 ##

//spring容器的初始化
    spring容器的refresh() 创建刷新
    1.prepareRefresh() 刷新前的预处理
    	1.1 initPropertySources();初始化一些属性设置，该方法为空方法，让子类自定义个性化属性配置
    	1.2 getEnvironment().validateRequiredProperties(); 检验属性的合法性等
    	1.3 Set<ApplicationEvent> earlyApplicationEvents = new LinkedHashSet<>(); 保存容器中的一些早期事件
    2.obtainFreshBeanFactory() 获取BeanFactory
    	2.1 refreshBeanFactory();刷新【创建】BeanFactory
    		2.1.1 在GenericApplicationContext构造方法中创建this.beanFactory = new DefaultListableBeanFactory();
    		2.1.2 设置序列化id
    	2.2 getBeanFactory();返回刚刚创建的BeanFactory对象。将创建的DefaultListableBeanFactory返回
    3.prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）
    	3.1 设置BeanFactory的类加载器、支持表达式解析器...
    	3.2 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
    	3.3 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware等
    	3.4 注册可以解析的自动装配，我们能直接在任何组件中自动注入：
    		BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
    	3.5 添加BeanPostProcessor【ApplicationListenerDetector】 事件探测器
    	3.6 添加编译时的AspectJ
    	3.7 给BeanFactory中注册一些能用的组件
    		environment【ConfigurableEnvironment】
    		systemProperties【Map<String, Object>】
    		systemEnvironment【Map<String, Object>】
    4.postProcessBeanFactory(beanFactory);BeanFactory准备工作完成之后进行的后置处理工作
    	空方法，子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的配置
    /****************以上是BeanFactory的创建即预准备工作************************/
    5.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor 
    	BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
    	两个接口：BeanFactoryPostProcessor（后执行）、BeanDefinitionRegistryPostProcessor(先执行)
    	5.1 执行PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());方法
    		5.1.1 先执行BeanDefinitionRegistryPostProcessor
    			5.1.1.1 获取所有的BeanDefinitionRegistryPostProcessor
    			5.1.1.2 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
    			遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
    			5.1.1.3 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
    			遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
    			5.1.1.4 最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor
    			遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
    		5.1.2 再执行BeanFactoryPostProcessors
    			5.1.2.1 获取所有的BeanFactoryPostProcessor
    			5.1.2.2 First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    			遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
    			5.1.2.3 Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    			遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
    			5.1.2.4 Finally, invoke all other BeanFactoryPostProcessors.
    			遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
    6.registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（bean的后置处理器）
    	不同接口类型的BeanPostFactory；在Bean创建前后的执行时机是不一样的
    	BeanPostProcessor
    	DestructionAwareBeanPostProcessor
    	InstantiationAwareBeanPostProcessor
    	SmartInstantiationAwareBeanPostProcessor
    	MergedBeanDefinitionPostProcessor
    	6.1 获取所有的BeanPostProcessor；后置处理器默认可以通过PriorityOrdered、Ordered接口来执行优先级
    	6.2 First, register the BeanPostProcessors that implement PriorityOrdered.
    		把每一个BeanPostProcessor，添加到BeanFactory中
    		beanFactory.addBeanPostProcessor(postProcessor);
    	6.3 Next, register the BeanPostProcessors that implement Ordered.
    	6.4 注册没有实现任何优先级接口的
    	6.5 注册internal BeanPostProcessors  【MergedBeanDefinitionPostProcessor】
    	6.6 最后注册一个ApplicationListenerDetector探测器，来在Bean创建完成后检查是否是ApplicationListener，如果是就注册
    		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    7.initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）
    	7.1 获取BeanFactory
    	7.2 先检查容器中是否有messageSource的，类型是messageSource
    		如果有赋值给messageSource，如果没有就创建一个DelegatingMessageSource，赋值给messageSource
    		messageSource：取出国际化配置文件中的某一个key的值，能按照区域信息获取
    		String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);
    	7.3 把创建好的MessageSource注册在容器中，以后获取国际化配置的时候，可以自动注入MessageSource
    		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
    8.initApplicationEventMulticaster(); 初始化事件广播器
    	8.1 获取BeanFactory
    	8.2 从BeanFactory中获取applicationEventMulticaster
    	8.3 如果上一步没有配置，创建一个SimpleApplcationEventMulticaster
    	8.4 将创建好的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自己注入
    9.onRefresh();
    	空实现，子类重写，在容器刷新的时候可以自定义逻辑
    10.registerListeners();初始化事件派发器、监听器等，给容器中把所有项目里ApplicationListener注册进来
    	10.1 从容器中获取所有的ApplicationListener
    	10.2 将每个监听器添加到事件派发器中
    	getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    	10.3 派发上面产生的事件
    	getApplicationEventMulticaster().multicastEvent(earlyEvent);
    11.finishBeanFactoryInitialization(beanFactory); 初始化剩下的单实例Bean
    	11.1 beanFactory.preInstantiateSingletons(); 初始化所有剩下的单实例Bean
    		11.1.1 获取容器中所有的Bean，依次进行初始化和创建对象
    		11.1.2 获取Bean的定义信息，RootBeanDefinition
    		11.1.3 判断Bean不是抽象的 且 是单实例的 且 不是懒加载的
    			11.1.3.1 判断是否是FactoryBean，即是否是实现了FactoryBean接口的Bean
    				如果不是FactoryBean，则getBean(beanName);创建对象
    					11.1.3.1.0)getBean(beanName);
    					11.1.3.1.1)doGetBean(name, null, null, false);
    					11.1.3.1.2)先获取缓存中的Bean，如果能获取到说明这Bean之前被创建过（所有创建过的Bean都会被缓存起来）
    					//Cache of singleton objects: bean name to bean instance.
    					private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);保存容器中共的单实例Bean
    					11.1.3.1.3)缓存中获取不到，开始Bean的创建对象流程，获取BeanFactory
    					11.1.3.1.4)标记当前Bean已经在被创建（防止多线程同时创建）
    					11.1.3.1.5)获取Bean的定义信息 RootBeanDefinition
    					11.1.3.1.6)【获取当前Bean依赖的其他Bean，如果有getBean()把依赖的Bean创建出来】
    					11.1.3.1.7)启动单实例Bean的创建流程
    						11.1.3.1.7.1 createBean(beanName, mbd, args);
    							1)Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    							InstantiationAwareBeanPostProcessors 提前执行
    							2)先依次触发所有BeanPostProcessor.postProcessBeforeInstantiation();
    							3)如果有返回值在依次触发BeanPostProcessor.postProcessAfterInitialization();
    						11.1.3.1.7.2 如果前面InstantiationAwareBeanPostProcessors没有返回代理对象，调用3）
    						11.1.3.1.7.3 doCreateBean(beanName, mbdToUse, args);创建Bean实例
    							1)创建Bean实例；createBeanInstance(beanName, mbd, args);
    							利用工厂方法或者对象的构造器创建出Bean实例
    							2)applyMergedBeanDefinitionPostProcessors();
    							调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
                                   3)Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
    								赋值之前：
    								①拿到InstantiationAwareBeanPostProcessor后置处理器
    								postProcessAfterInstantiation()
    								②拿到InstantiationAwareBeanPostProcessor后置处理器
    								postProcessPropertyValues()
                                       -------赋值之前---------
                                       ③应用Bean属性值：为属性利用setter方法等进行赋值
                                       applyPropertyValues(beanName, mbd, bw, pvs);
    							4)【Bean初始化】initializeBean(beanName, exposedObject, mbd);
    							5)【注册Bean的销毁方法】registerDisposableBeanIfNecessary(beanName, bean, mbd);
    						11.1.3.1.7.4 将创建的Bean添加到缓存中singletonObjects:
    						ioc容器就是这些Map;很多的Map里面保存了单实例Bean，环境信息等....
                        所有的Bean都利用getBean创建完成之后
                        	检查所有的Bean是否是SmartInitializingSingleton接口的实现类，如果是就执行smartSingleton.afterSingletonsInstantiated();
    12.finishRefresh();完成BeanFactory的初始化创建工作；IOC容器创建完成；
    	12.1 initLifecycleProcessor();初始化与生命周期相关的后置处理器；LifecycleProcessor
    	默认从容器中找是否有lifecycleProcessor的组件，如果没有获取到，创建一个默认的 new DefaultLifecycleProcessor();  加入到容器中
    	自定义LifecycleProcessor的是实现类，可以回调
    		void onRefresh(); //Notification of context refresh
    		void onClose(); //Notification of context close phase
    	12.2 getLifecycleProcessor().onRefresh();
    	拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh();
    	12.3 publishEvent(new ContextRefreshedEvent(this)); 
    	发布容器刷新完成事件
    	12.4 LiveBeansView.registerApplicationContext(this);
    
    
    	------总结-------
    	1.spring容器在启动的时候，会先保存所有注册进来的Bean的定义信息
    		1.1 XML注册bean: <bean/>
    		1.2 注解注册Bean：@Service @Component @Bean ...
    	2.spring会找到合适的时机创建这些Bean
    		2.1 用到这个Bean的时候，利用getBean创建Bean;创建好之后保存在容器中
    		2.2 统一创建剩下所有的bean的时候，finishBeanFactoryInitialization()
    	3.后置处理器：BeanPostProcessor
    		3.1 每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
    			AutowiredAnnotationBeanPostProcessor 处理自动注入
    			AnnotationAwareAspectJAutoProxyCreator 来做AOP功能
    			增强的功能注解：
    			AsyncAnnotationBeanPostProcessor
    	4.事件驱动模型
    		ApplicationListener 事件监听
    		ApplicationEventMulticaster 事件派发器
    
    
    
    -------其他需要注意---------
    1.如果类实现了InitializingBean 接口
        1.1 Spring为bean提供了两种初始化bean的方式，实现InitializingBean接口，实现afterPropertiesSet方法，或者在配置文件中通过init-method指定，两种方式可以同时使用。
        1.2实现InitializingBean接口是直接调用afterPropertiesSet方法，比通过反射调用init-method指定的方法效率要高一点，但是init-method方式消除了对spring的依赖。
        1.3如果调用afterPropertiesSet方法时出错，则不调用init-method指定的方法。
        1.4如果即实现了InitializingBean，又指定了init-method，就先调用afterPropertiesSet，再调用init-method
    
    2.如果类实现了FactoryBean接口
    可以让我们自定义Bean的创建过程 
        public interface FactoryBean<T> {
        
            //返回的对象实例
            T getObject() throws Exception;
            //Bean的类型
            Class<?> getObjectType();
            //true是单例，false是非单例  在Spring5.0中此方法利用了JDK1.8的新特性变成了default方法，返回true
            boolean isSingleton();
        }
    3.BeanFactory接口
    BeanFactory是Spring容器中的一个基本类也是很重要的一个类，在BeanFactory中可以创建和管理Spring容器中的Bean，它对于Bean的创建有一个统一的流程。