spring容器的refresh()方法解释

做个笔记spring容器refresh();创建以及刷新工作

***1、prepareRefresh();预处理***
	1)、initPropertySources();初始化一些属性设置；子类自定义个性化的设置方法
	2)、getEnvironment().validateRequiredProperties();检验属性的合法等
	3)、this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();保存容器中一些早期的事件；
***2、this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();获取bean工厂***
	1)、refreshBeanFactory();刷新【创建】bean工厂
		创建了一个beanFactory this.beanFactory = new DefaultListableBeanFactory();
		this.beanFactory.setSerializationId(getId());设置id
	2)、getBeanFactory();返回第一步GenericApplicationContext创建的beanFactory
	3)、将创建beanFactory【DefaultListableBeanFactory】返回；
***3、prepareBeanFactory(beanFactory);beanFactory的预准备工作（对beanFactory设置一些属性）；***
	1)、设置beanFactory的类加载器、支持表达解析器
	2)、添加部分addBeanPostProcessor【ApplicationContextAwareProcessor】
	3)、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx
	4)、注册可以解析的自动装配；我们能直接任何组件中直接注入：
				Beanfactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
	5)、再次添加后置处理器【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)、执行invokeBeanFactoryPostProcessors【invokeBeanFactoryPostProcessors】
	    		1)、先执行BeanDefinitionRegistryPostProcessor
		    		1)、获取所有的 BeanDefinitionRegistryPostProcessor
		    		2)、看先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor执行postProcessor.postProcessBeanDefinitionRegistry(registry);这个方法
		    		3)、再执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor执行postProcessor.postProcessBeanDefinitionRegistry(registry);这个方法
					4)、最后执行没有实现任何接口的BeanDefinitionRegistryPostProcessor执行postProcessor.postProcessBeanDefinitionRegistry(registry);这个方法
				2)、再执行BeanFactoryPostProcessor
					1)、获取所有的 BeanDefinitionRegistryPostProcessor
		    		2)、看先执行实现了PriorityOrdered接口的BeanPostProcessor执行postProcessor.postProcessBeanFactory(beanFactory);这个方法
		    		3)、再执行实现了Ordered接口的BeanPostProcessor执行postProcessor.postProcessBeanFactory(beanFactory);这个方法
					4)、最后执行没有实现任何接口的BeanPostProcessor执行postProcessor.postProcessBeanFactory(beanFactory);这个方法
***6、registerBeanPostProcessors(beanFactory);注册beanPostProcessor（Bean后置处理器）【Register bean processors that 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)、最后注册没有实现任何优先级接口的beanPostProcessor
	5)、最终重新注册一遍MergedBeanDefinitionPostProcessor
	6)、最最后还注册一个自己新建的处理器【ApplicationListenerDetector】用来检查bean创建完成后检查这个bean是不是ApplicationListener，
		如果是this.applicationContext.addApplicationListener((ApplicationListener<?>) bean); 
***7、initMessageSource();初始化MessageSource组件（做国际化功能，消息绑定，消息解析）***
	1)、获取beanFactory；getBeanFactory();
	2)、判断id中是否有名称为messageSource组件
		如果有的话直接复制给AbstractApplicationContext容器的messageSource属性；如果没有自己就创建一个DelegatingMessageSource且赋值messageSource
			MessageSource：取出国际化配置文件中的某个key的值；能按照区域获取信息
	3)、把创建好的MessageSource注册在容器中，以后获取的话自动注入MessageSource调用String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException;
		beanFactory.registerSingleton();
***8、initApplicationEventMulticaster();初始化时间发布的多播器【派发器】***
	1)、获取beanFactory；getBeanFactory();
	2)、beanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster组件
	3)、如果没有配置就自己创建一个SimpleApplicationEventMulticaster事件派发器且注册在容器中，以后要使用就自动注入
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
***9、onRefresh();留给子类的*** 
	1)、子类重写这个方法，在容器刷新的时候可以自定义逻辑（比如刷新容器的时候可以往容器中注册一些其他的组件）
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来
	1)、从容器中拿到ApplicationListener
		 getBeanNamesForType(ApplicationListener.class, true, false);
    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，就利用geBean(bean);创建对象
				geBean(beanName)步骤：
					1)、doGetBean(name, null, null, false);
					2)、先获取缓存中单实例bean，如果能获取到说明这个Bean之前被创建过（所有被创建过的bean都会被缓存起来）
						从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
			3)、缓存中没有拿到，就开始Bean的创建对象流程;
			4)、markBeanAsCreated(beanName);标记当前Bean正在被创建
			5)、获取Bean的定义信息 getMergedLocalBeanDefinition(beanName);【RootBeanDefinition】
			6)、mbd.getDependsOn();获取当前bean所依赖的其他bean； 如果有就先用geBean(beanName)的方式把依赖bean先创建好
			7)、启动单实例Bean的创建流程；
			    1)、调用createBean(beanName, mbd, args);
			    2)、resolveBeforeInstantiation(beanName, mbdToUse);让beanPostProcessor先拦截返回代理对象
			 		 提前执行InstantiationAwareBeanPostProcessors后置处理器
			 		先 触发postProcessBeforeInstantiation(beanClass, beanName);如果有返回值在执行applyBeanPostProcessorsAfterInitialization(bean, beanName);
			    3)、如果前面的InstantiationAwareBeanPostProcessors没有返回代理对象
			    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)、populateBean(beanName, mbd, instanceWrapper);为bean的属性赋值
			  			赋值之前：
			  			1)、拿到所有的后置处理器beanPostProcessor判断是否为InstantiationAwareBeanPostProcessor后置处理器
			  					postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)执行
			  			2)、再次拿到所有的后置处理器beanPostProcessor判断是否为InstantiationAwareBeanPostProcessor后置处理器
			  					postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);执行
			  				==========赋值之前============
			  		    3)、applyPropertyValues(beanName, mbd, bw, pvs);给bean属性赋值【用反射掉set方法】
			  		4)、 initializeBean(beanName, exposedObject, mbd);bean初始化
			  		 	1)、【先执行Aware接口方法】invokeAwareMethods(beanName, bean);执行aware接口的方法
			  		 		BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
			  		 	2)、【后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
			  		 		BeanPostProcessor.postProcessBeforeInitialization();
			  		 	3)、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
			  		 		1)、是否是InitializingBean接口的实现方法执行接口规定的初始化
			  		 		2)、如果不是判断是否有自定义的初始化方法就是@Bean（init=“”）
			  		 	4)、【后置处理器执行初始化之后的方法】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
			  		 		beanProcessor.postProcessAfterInitialization(result, beanName);
			  	    5)、【注册bean 的销毁方法】registerDisposableBeanIfNecessary(beanName, bean, mbd);
			  	 5)、讲创建的Bean添加到缓存中singletonObjects【单利池】
		  	 ioc容器就是这个流程中创建的这些map，里面保存了单实例Bean、环境信息、以及一些依赖关系
		 所有bean 都用getBean（）；创建完成之后
		 	检查这些Bean是否是SmartInitializingSingleton接口的：如果是就执行它的afterSingletonsInstantiated方法
***12、finishRefresh();完成BeanFactory的创建工作；ioc容器就创建完成了***		
	1)initLifecycleProcessor();	初始化和生命周期相关的后置处理器；LifecycleProcessor
		写一个LifecycleProcessor的实现类，可以再beanFactory的生命周期
		默认从容器中过找是否有这个组件；如果没有就用默认DefaultLifecycleProcessor的组件且注册在容器中 
			void onRefresh();
			void onClose();
	2)、拿到上面初始化的组件回调这个方法getLifecycleProcessor().onRefresh(); 	
	3)、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件
	4)、LiveBeansView.registerApplicationContext(this);

## 标题