spring容器的refresh()方法流程

spring容器的refresh()方法

总体流程如下，细节暂未看完

1、propareRefresh() 刷新前的预处理;
	1)、initPropertySources()初始化一些属性设置，子类可重写自定义个性化的属性设置
	2)、getEnvironment().validateRequireProperties()校验属性合法
	3)、this.earlyApplicationEvents = new LinkedHashSet<>();保存容器的早期事件
2、ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()；获取beanFactory
	1）、refreshBeanFactory();刷新beanFactory
		->this.beanFactory.setSerializationId(getId());设置id
	2）、getBeanFactory();返回beanFactory
3、prepareBeanFactory(beanFactory); beanFactory的准备工作 对beanFactory进行一些设置
	1）、设置beanFactory的类加载器、支持表达式解析
	2）、添加部分BeanPostProcessor  【ApplicationContontextAwareProcessor】
	3）、设置忽略自动状态的接口 EnvironmentAware、EmbedValueResolverAware、xx
	4）、注册可以解析的自动装配 我们能在任何组件中自动注入
			beanFactory、ResourceLoader、ApplicationEventPulisher、ApplicationContext
	5）、添加BeanPostProcessor[ApplicationListenerDetector]
	6）、添加编译时的AspectJ
	7）、给BeanFactory中注册一些能用的组件：
	environment[ConfigurableEnvironment]
	systemProperties[Map<String,Object]
	systemEnvironment[Map<String,Object]
4、	postProcessBeanFactory(beanFactory);beanFactory的准备工作完成后进行的操作
	1）、子类可以来重写来及进一步设置属性，比如servletContext
5、	invokeBeanFactoryPostProcessors执行beanFactory的后置处理器
	->BeanFactoryPostProcessor
		->BeanDefinitionRegistryPostProcessor
	1）、获取所有的后置处理器
	2）、判断是不是BeanDefinitionRegistryPostProcessor，是的话执行registryProcessor.postProcessBeanDefinitionRegistry(registry);
	并且把两种类型的后置处理器分开
	3）、优先执行BeanDefinitionRegistryPostProcessor里面的postProcessBeanFactory
		->实现PriorityOrdered接口的执行
		->实现Ordered接口的次之
		->执行没有任何优先级的
	4）、BeanFactoryPostProcessor继续按照上述流程执行
6）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器

	下面又有几大接口，不同类型的执行时机不同
	->BeanPostProcessor
		->DestructionAwareBeanPostProcessor执行bean的销毁方法后置处理器
		->InstantiationAwareBeanPostProcessor
			->SmartInstantiationAwareBeanPostProcessor
		->MergedBeanDefinitionPostProcessor 存放咋internalPostProcessors里面，
	1）、获取所有的BeanPostProcessor，根据优先级区分，接着排序
	2）、优先注册PriorityOrdered的PostProcessor
	3）、再注册实现order的的BeanPostProcessors
	4）、最后注册普通的的，没有实现优先接口的
	5）、registerBeanPostProcessors(beanFactory, internalPostProcessors);
	6）、beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
7）、initMessageSource();国际化相关
	1）、容器里面有没有id=messageSource的组件，如果有赋值给messageSource属性，没有创建一个默认DelegatingMessageSource，取出国际化配置文件中的值，可以根据区域信息获取
	2）、注册MessageSource
8）、initApplicationEventMulticaster初始化事件派发器
	1）、获取beanFactory
	2）、从beanFactory获取applicationEventMulticaster派发器
	3）、没有创建一个new SimpleApplicationEventMulticaster(beanFactory)
	4）、将上一步的派发器注入
9）、onRefresh();留给子类重写
	1）、子类
10）、registerListeners()检查容器里面的监听器并注册
	1）、获取所有的ApplicationListener组件
	2）、getApplicationEventMulticaster().addApplicationListener(listener);将监听器添加到派发器里面
	3）、Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
		检查早期事件有没有，有的发直接派发
11）、finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean
	1）、一顿操作到了beanFactory.preInstantiateSingletons();
	2）、List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);获取所有的bean定义
	3）、遍历，获取单个bean定义，不是抽象，是单实例，不是懒加载
		-> 判断是不是工厂bean if (isFactoryBean(beanName))有没有实现工厂
			->是，利用getObject()获取对象，遮脸还有判断
			->不是getBean(beanName);
				->doGetBean
					->1.Object sharedInstance = getSingleton(beanName);获取缓存中的bean如果有的话直接取			
						->获取private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
					->缓存为空，获取父容器
					->没有父工厂
					->markBeanAsCreated(beanName);标记bean是否被创建
					->获取bean的定义信息
					->根据bean依赖的bean先创建，String[] dependsOn = mbd.getDependsOn();
					->是单实例getSingleton
						->Object bean = resolveBeforeInstantiation(beanName, mbdToUse);//给个机会从后置拦截器里面返回对象
						->InstantiationAwareBeanPostProcessor的方法，说明这个类在实例化之前
						->先执行postProcessBeforeInstantiation有返回值，执行postProcessAfterInitialization
					->上一步没有返回代理对象，执行doCreateBean创建bean
						->1.创建bean实例instanceWrapper = createBeanInstance(beanName, mbd, args);
						->2.创建完之后执行
						applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)，接着添加到单实例bean里面
						->3.属性赋值 populateBean(beanName, mbd, instanceWrapper);//bean的属性赋值
							->InstantiationAwareBeanPostProcessor赋值之前遍历所有的后置处理器，执行他的postProcessAfterInstantiation
							->继续上一个后置处理器的postProcessProperties,返回PropertyValues，此时还为负值
							->checkDependencies(beanName, mbd, filteredPds, pvs);//检查
							->applyPropertyValues(beanName, mbd, bw, pvs);//赋值
						->4.bean 初始化 exposedObject = initializeBean(beanName, exposedObject, mbd);
							->[先aware接口的方法]invokeAwareMethods(beanName, bean);
							->[后置处理器初始化之前的方法]postProcessBeforeInitialization
							->[初始化方法]invokeInitMethods(beanName, wrappedBean, mbd);
								->是否是InitializingBean接口，是的话执行初始哈方法
								->[自定义初始化方法]invokeCustomInitMethod
							->applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);后置处理器的postProcessAfterInitialization方法
							->[注册销毁方法]registerDisposableBeanIfNecessary(beanName, bean, mbd);
				->全部实例化之后，检查是不是SmartInitializingSingleton接口
				是的话执行afterSingletonsInstantiated
12）、finishRefresh();完成刷新
		//清除上下文级资源缓存（例如扫描中的ASM元数据)5.0新增
		clearResourceCaches();
		
		//生命周期函数，没有会有默认
		// Initialize lifecycle processor for this context.
		initLifecycleProcessor();
		
		//回调声明周期处理器的回调
		// Propagate refresh to lifecycle processor first.
		getLifecycleProcessor().onRefresh();
		
		//发布事件，容器刷新完成
		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);