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

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的创建有一个统一的流程。