Spring初始化容器与创建bean的过程
Spring容器的创建以及级初始化过程
通过使用AnnotationConfigApplicationContext这个类来创建一个bean容器，我们从这个类进去看看，Spring怎么给我们来创建对象的
Spring容器的refresh（）【创建刷新】
1、prepareRefresh();刷新前的预处理
1）initPropertySources();初始化一些属性设置，留给子类来初始化信息，在子类自定义个性化的属性设置方式
2）getEnviornment().validateRequiredProperties();检验属性的合法
3）earlyApplicationEvents=new LinkedHashSet<Application>();保存容器中的一些时间，由事件派发器发送事件
2、obtainFreshBeanFactory();获取BeanFactory;
1）refreshBeanFactory();刷新【创建】BeanFacory
创建一个this.beanFactory=new DefaultListBeanFactory();
设置id
2）getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象
3）将创建的BeanFactory【DefaultListenerBeanFactory】返回
3、prepareBeanFactory(beanFactory)；BeanFactory的预备工作（Beanfactory进行一些设置）
1）设置BeanFactory的类加载器、支持表达式解析器
2）添加部分BeanFactoryProcessor
3）设置忽略自动装配的接口EnvironmentAware、
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创建并预备完成以后进一步的设置
============================以上是BeanFactory的创建以及预备工作===================================
5、invokeBeanFactoryPostProcessor(beanFactory);执行BeanFactoryPostProcessor
BeanFactoryPostProcessor；BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的
两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
1）、按优先级执行Bean一些Processor
6、registerBeanPostProcessors（beanFactory）;注册BeanPostProcessor（Bean的后置处理器）【interceptor】
不同接口类型的BeanProcessor，在Bean创建后的执行时机是不一样的
获取一些Processor并执行
7、initMessageSource()；初始化MessageSource组件（做国际化功能，消息绑定，消息解析）
1）获取BeanFactory
2）看容器中是否有id为messageSource的，类型是MessageSource的组件
3）创建MessageSource注册在容器中
8、initApplicationEventMulticaster()；初始化事件派发器
1）获取BeanFactory
2）从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
3）如果上一步没有配置，创建一个SimpleApplicationEventMulticaster
4）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他事件直接自动注册
9、onrefresh()；留给子类容器（子类）
1）子类重写这个方法，在容器刷新的时候可以自定义逻辑
10、registerListeners()；将所有项目中的ApplicationListener
1）从容器中拿到所有的ApplicationListener
2）将每个监听器添加到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName)
3）派发之前步骤产生的事件
11、finishBeanFactoryInitialization(beanFactory)；初始化所有剩下的单实例bean
1、beanFactory.preInstantiatteSingletons()；初始化后剩下的单实例bean
1）获取bean容器中的所有bean，一次进行初始化和创建对象
2）获取bean的定义信息，RootBeanDefinition
3）Bean不是抽象的，是单实例的，是懒加载
1）判断是否是FactoryBean；是否实现FactoryBean接口的Bean
2）不是工厂bean。利用getBean(beanName)；创建对象
0、getBean(beanName)；ioc.getBean();
1、doGetBean(name,null,null,false)
2、先获取缓存中保存的单实例Bean，如果能获取到，说明这个Bean之前被创建过（所有创建过的实例Bean都会被缓存起来）
从private final Map<String,Object> singletonObjects=new ConcurrentHashMap<String,Object>()
3、缓存中获取不到、开始Bean的创建对象流程
4、标记当前bean已经被创建（多线程）
5、获取Bean的定义信息
6、获取当前Bean依赖的其他Bean；如果有按照getBean()把依赖的Bean先创建出来
7、启动单实例Bean的创建流程：
1）createBean(beanName,mbd,args);
2）Object bean=resolveBeforeInstantiation(beanName,mbdToUse)，让Bean
【InstantiationAwareBeanPostProcessor】：提前执行
先触发：postProcessorBeforeInstantiation();
如果有返回值：触发postProcessorAfterInitiazation()；让BeanPostProcessor先拦截返回代理对象
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.postProcessorMergedBeanDefinition(mbd，beanType，beanName)；
3） 【Bean属性赋值】populateBean(beanName,mbd,instanceWapper) ；
1）拿到InstantiationAwareBeanPostProcessor后置处理器，postProcessorInstantiation()；
postProcessorAfterINstantiation()；
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）【执行后置处理器初始化之前】applyBeanPostProcessorBeforeINitialization（wrappedBean,bean）
BeanPostProcessor.postProcessorBeforeInitialization（）；
3）【执行初始化方法】invokeInitMethods(beanName，wrappedBean，mbd)；
1）是否是InitializingBean接口的实现，执行接口规定的初始化
2）是否自定义初始化方法
4）【执行后置处理器初始化之后】applyBeanPostProcessorAfterInitialization
BeanPostProcessor.postProcessorAfterINitialization（）
5）注册Bean的销毁方法
5）将创建的Bean添加到缓存中singleonObjects
ioc容器就是这些Map，很多Map里面保存了单实例Bean，环境信息
所有Bean的都利用getBean创建完成后
检查所有的Bean是否是SmartInitializingSingleton接口的，如果是，就执行afterSingletonInstantiated()
12、finshRefresh()；完成BeanFactory 的初始化创建工作，IOC容器就创建完成
1)、initLifecycleProcessor()；初始化和生命周期有关的后置处理器；lifecycleProcessor
默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultlifecycleProcessor
加入到容器
写一LifecycleProcessor的实现类，可以在BeanFactory
void onRefresh()
void onClose()
2)、getLifecycleProcessor().onRefresh()；
拿到前面定义的生命周期处理器（BeanFactory）;回调onRefresh();
3）publishEvent(new ContextRefreshEvent(this))；发布容器刷新完成事件
4）iveBeanView.registerApplicationContext(this)
=================总结====================
1）spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息
1）xml注册bean；<bean>
2）注解注册Bean；@Service、@Component、@Bean、XXX
2）Spring容器会合适的时机创建这些Bean
1）用到这个bean的时候，利用getBean创建bean；创建好以后保存在容器中
2）统一创建剩下所有的bean的时候，finishBeanFactoryInitization()；
3）后置处理器；
1）每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能
AutowiredAnnotationBeanPostProcessor：处理自动注入
AnnotationAwareAspectJAutoProxyCreator：来做AOP功能
增强的功能注解
AsyncAnnotationBeanPostProcessor
4）事件驱动模型；
ApplicationListener：事件监听
ApplicationEventMulticaster事件派发
