Spring容器的refresh 创建刷新：
1-prepareRefresh刷新前的预处理：
initPropertySources 初始化一些属性配置，原来是空的，子类自定义的属性设置方法 getEnvironment().validateRequiredProperties();检验属性的合法性 this.earlyApplicationEvents = new LinkedHashSet<>();保存容器中的一些早期的事件
2-obtainFreshBeanFactory();获取BeanFactory
refreshBeanFactory(); 刷新BeanFactory;（在GenericApplicationContext类里面）
创建了this.beanFactory = new DefaultListableBeanFactory();
设置idthis.beanFactory.setSerializationId(getId());
getBeanFactory()返回刚才GenericApplicationContext构造器创建的BeanFactory对象
将创建的的BeanFactory[DefaultListableBeanFactory]返回
3-prepareBeanFactory(beanFactory); BeanFactory的预备工作，BeanFactory进行一些设置
1设置BeanFactory类的类加载器，支持表达式解析器。。。。。 2beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));添加部分的BeanPostProcessor 3设置忽略的自动装配的接口(就是不能通过实现接口进行加载)，包括EnvironmentAware EmbeddedValueResolverAware 4beanFactory.registerResolvableDependency
注册可以解析的自动装配(就是通过autowire) 包括BeanFactory ResourceLoader ApplicationEventPublisher 5添加BeanPostProcessor(ApplicationListenerDetector) 6添加编译时的AspetJ 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子接口
1-执行BeanFactoryPostProcessor的方法：
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
先执行这个后置处理器BeanDefinitionRegistryPostProcessor
1-获取所有的BeanDefinitionRegistryPostProcessor
2-看优先级排序，先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
执行后置处理器方法postProcessor.postProcessBeanDefinitionRegistry
3-在执行实现了Ordered.class顺序接口的BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
4-最后执行没有实现优先级或者顺序接口的BeanDefinitionRegistryPostProcessor
再执行BeanFactoryPostProcessor的方法
其实流程和上面那个处理器一样
6-registerBeanPostProcessors(beanFactory);注册BeanPostProcessors,Bean的后置处理器，拦截Bean创建的过程
1-获取所有的BeanPostProcessor
不同类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的
DestructionAwareBeanPostProcessor【存放位置】
InstantiationAwareBeanPostProcessor，【存放位置】
SmartInstantiationAwareBeanPostProcessor，【存放位置】
MergedBeanDefinitionPostProcessor【存放位置internalPostProcessors】
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); (后置处理器都有优先级) 2-注册PriorityOrderd优先级接口的BeanPostProcessor：
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
实际上就是将每一个BeanPostProcessor，添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor); 3-在注册Oreder接口的
4-最后注册么有实现任何接口的
5-最终注册的是MergedBeanDefinitionPostProcessor类型的
6-最后最后注册ApplicationListenerDetector：来创建Bean完成后检查是否是ApplicationListener，如果是的化就进行下面带#号的语句
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); ######this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7-initMessageSource();初始化MessageSource组件（座国际化功能，消息绑定，消息解析）
1-获取BeanFactory:
ConfigurableListableBeanFactory beanFactory = getBeanFactory(); 2-看容器中是否包含id为 messageSource组件
如果有就赋值给该类的属性
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
如果没有新建一个DelegatingMessageSource dms = new DelegatingMessageSource();
MessageSource 取出国际化配置文件中的某个key的值，能按照区域信息获取 3-把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，自动注入MessageSource即刻
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);
8-initApplicationEventMulticaster();初始化事件派发器
1-获取BeanFactory
2-从BeanFactory中获取ApplicationEventMulticaster
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); 3-如果上一步没有配置，创建一个SimpleApplicationEventMulticaster
SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); 4-将创建的ApplicationEventMulticaster 添加到BeanFactory中，以后可以自动注入
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
9-onRefresh();留给子容器（子类）
子类重写这个方法，在容器刷新的时候可以自定义逻辑
10-registerListeners();给容器中将所有项目里面的ApplicationListener注册进来
1-从容器中拿到ApplicationListener
getApplicationListeners()
2-将每个监听器，提娜佳到事件派发起
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); 3-派发之前步骤产生的事件：
getApplicationEventMulticaster().multicastEvent(earlyEvent);
11-finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例Bean
1-beanFactory.preInstantiateSingletons();初始化剩下的单实例Bean
1-获取容器中所有的Bean,依次进行初始化和创建对象
beanNames = new ArrayList<>(this.beanDefinitionNames);
2-获取Bean的定义信息：RootBeanDefinition
3-如果bean不是抽象的额，是单实例的，是懒加载：
1-判断是否是FactoryBean，是否是实现FactoryBean接口的Bean,如果是工厂bean就会用工厂的getObject来创建对象
2-如果不是直接利用getBean(beanName)创建对象
getBean(beanName)怎么做：
1-调用doGetBean
2-先获取缓存中的单实例bean,如果能够获取到，Bean是之前被创建的（所有被创建锅的Bean都会被缓存起来）
Object sharedInstance = getSingleton(beanName);
3-获取不到，开始创建对象流程：
4-标记当前bean已经被创建markBeanAsCreated(beanName);
5-获取Bean的定义信息RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
6-获取当前Bean依赖的信息：String[] dependsOn = mbd.getDependsOn();并通过getBean创建出来
7-启动单实例Bean的创建过程if (mbd.isSingleton())
1-createBean(beanName, mbd, args)
2-让BeanPostProcess进行拦截执行
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
执行的类型是：InstantiationAwareBeanPostProcessor类型
触发Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
如果有放回值，执行 processor.postProcessAfterInitialization(result, beanName); 3-如果前面InstantiationAwareBeanPostProcessor没有返回代理对象
执行：Object beanInstance = doCreateBean(beanName, mbdToUse, args);
执行doCreateBean的流程
通过bean构造器创建Bean
instanceWrapper = createBeanInstance(beanName, mbd, args); applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor的方法：
processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
位Bean属性赋值populateBean(beanName, mbd, instanceWrapper);
赋值之前
1-拿到InstantiationAwareBeanPostProcessor 后置处理器：
执行bp.postProcessAfterInstantiation
2-在其拿到InstantiationAwareBeanPostProcessor 后置处理器
执行bp.postProcessPropertyValues
3-应用Bean属性的值，为属性利用setter方法进行赋值现在才开始赋值applyPropertyValues(beanName, mbd, bw, pvs);
Bean初始化
initializeBean(beanName, exposedObject, mbd);
1-invokeAwareMethods(beanName, bean);执行Aware接口的方法。
BeanNameAware
BeanClassLoaderAware
BeanFactoryAware
2-执行后置处理器初始化之前的方法：BeanPostProcessor
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
调用processor.postProcessBeforeInitialization(result, beanName);
3-执行初始化方法：InitializingBean
1-判断是否是InitializingBean接口，执行规定的初始化方法：
2-判断是否自定义初始化方法
4-执行后置处理器初始化
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessAfterInitialization
注册Bean的销毁方法：
registerDisposableBeanIfNecessary(beanName, bean, mbd);
最后是将Bean添加到缓存当中的singletonObjects
备注：IOC容器就是这些Map,很多Map里面保存了单实例Bean，环境信息等
DefaultListableBeanFactory
所有Bean都利用getBean完成之后：
检查所有的Bean是否是SmartInitializingSingleton接口的，如果是，
就执行smartSingleton.afterSingletonsInstantiated();
12-finishRefresh() 完成BeanFactory的初始化创建工作，IOC容器就创建完成！！！
初始化和生命周期有关的后置处理器initLifecycleProcessor();LifecycleProcessor
写一个LifecycleProcessor的实现类，可以在BeanFactory两个阶段
void onRefresh() void onClose()
如果没有自定义生命周期，则容器会新建一个 new DefaultLifecycleProcessor();并注册到容器当中去：
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor); 拿到前面的生命周期，回调onRefresh()方法，getLifecycleProcessor().onRefresh(); 发布容器刷新完成事件publishEvent(new ContextRefreshedEvent(this)); LiveBeansView.registerApplicationContext(this);
spring容器总结
1-Spring容器在启动的时候，贤惠保存所有注册进来的Bean定义信息
1-1xml注册bean<bean>
1-2注解注册Bean @Service @Component
2-Spring容器会合适的时机创建那就这些Bean
2-1用到这个Bean的时候，利用getBean创建Bean,并保存到容器中
2-2统一创建所有剩下的Bean,finishBeanFactoryInitialization
3-后置处理器：
3-1每个Bean的创建完成，都会使用各种后置处理器进行处理，来增强bean的功能
AutowiredAnnotationBeanPostProcessor 处理自动注入
AnnotationAwareAspectJAutoProxyCreator 做AOP功能
增强的功能注解，都是通过后置处理器来完成的
AsyncAnnotationBeanPostProcessor
4-事件驱动模型：
ApplicationListener：事件监听
ApplicationEventMulticaster事件派发
