Spring容器的启动流程
Spring的启动流程可以归纳为三个步骤：
1、初始化Spring容器，注册内置的BeanPostProcessor的BeanDefinition到容器中2、将配置类的BeanDefinition注册到容器中3、调用refresh()方法刷新容器因为是基于java-config技术分析源码，所以这里的入口是AnnotationConfigApplicationContext，如果是使用xml分析，那么入口即为ClassPathXmlApplicationContext，它们俩的共同特征便是都继承了AbstractApplicationContext类，而大名鼎鼎的refresh()便是在这个类中定义的。我们接着分析AnnotationConfigApplicationContext类，源码如下：
//初始化容器publicAnnotationConfigApplicationContext(Class?...annotatedClasses){//注册Spring内置后置处理器的BeanDefinition到容器this();//注册配置类BeanDefinition到容器register(annotatedClasses);//加载或者刷新容器中的Beanrefresh();}所以整个Spring容器的启动流程可以绘制成如下流程图：
接着我们主要从这三个入口详细分析一下Spring的启动流程：
一、初始化流程：
1、spring容器的初始化时，通过this()调用了无参构造函数，主要做了以下三个事情：
（1）实例化BeanFactory工厂，用于生成Bean对象（2）实例化BeanDefinitionReader注解配置读取器，用于对特定注解（如
Service、Repository）的类进行读取转化成BeanDefinition对象，（BeanDefinition是Spring中极其重要的一个概念，它存储了bean对象的所有特征信息，如是否单例，是否懒加载，factoryBeanName等）（3）实例化ClassPathBeanDefinitionScanner路径扫描器，用于对指定的包目录进行扫描查找bean对象2、核心代码剖析：（1）向容器添加内置组件：org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors：
根据上图分析，代码运行到这里时候，Spring容器已经构造完毕，那么就可以为容器添加一些内置组件了，其中最主要的组件便是ConfigurationClassPostProcessor和AutowiredAnnotationBeanPostProcessor，前者是一个beanFactory后置处理器，用来完成bean的扫描与注入工作，后者是一个bean后置处理器，用来完成
AutoWired自动注入。二、注册SpringConfig配置类到容器中：
1、将SpringConfig注册到容器中：org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean：
这个步骤主要是用来解析用户传入的Spring配置类，解析成一个BeanDefinition然后注册到容器中，主要源码如下：
TvoiddoRegisterBean(ClassTannotatedClass,
NullableSupplierTinstanceSupplier,NullableStringname, NullableClass?extendsAnnotation[]qualifiers,BeanDefinitionCustomizer...definitionCustomizers){ //解析传入的配置类，实际上这个方法既可以解析配置类，也可以解析Springbean对象 AnnotatedGenericBeanDefinitionabd=newAnnotatedGenericBeanDefinition(annotatedClass); //判断是否需要跳过，判断依据是此类上有没有Conditional注解 if(this.conditionEvaluator.shouldSkip(abd.getMetadata())){ return; } abd.setInstanceSupplier(instanceSupplier); ScopeMetadatascopeMetadata=this.scopeMetadataResolver.resolveScopeMetadata(abd); abd.setScope(scopeMetadata.getScopeName()); StringbeanName=(name!=null?name:this.beanNameGenerator.generateBeanName(abd,this.registry)); //处理类上的通用注解 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); if(qualifiers!=null){ for(Class?extendsAnnotationqualifier:qualifiers){ if(Primary.class==qualifier){ abd.setPrimary(true); } elseif(Lazy.class==qualifier){ abd.setLazyInit(true); } else{ abd.addQualifier(newAutowireCandidateQualifier(qualifier)); } } } //封装成一个BeanDefinitionHolder for(BeanDefinitionCustomizercustomizer:definitionCustomizers){ customizer.customize(abd); } BeanDefinitionHolderdefinitionHolder=newBeanDefinitionHolder(abd,beanName); //处理scopedProxyMode definitionHolder=AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,definitionHolder,this.registry); //把BeanDefinitionHolder注册到registry BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder,this.registry);}三、refresh()容器刷新流程：
refresh()主要用于容器的刷新，Spring中的每一个容器都会调用refresh()方法进行刷新，无论是Spring的父子容器，还是SpringCloudFeign中的feign隔离容器，每一个容器都会调用这个方法完成初始化。refresh()可划分为12个步骤，其中比较重要的步骤下面会有详细说明。
1、refresh()方法的源码：org.springframework.context.support.AbstractApplicationContext#refresh：
publicvoidrefresh()throwsBeansException,IllegalStateException{ synchronized(this.startupShutdownMonitor){ //1.刷新前的预处理 prepareRefresh(); //2.获取beanFactory，即前面创建的 ConfigurableListableBeanFactorybeanFactory=obtainFreshBeanFactory(); //3.预处理beanFactory，向容器中添加一些组件 prepareBeanFactory(beanFactory); try{ //4.子类通过重写这个方法可以在BeanFactory创建并与准备完成以后做进一步的设置 postProcessBeanFactory(beanFactory); //5.执行BeanFactoryPostProcessor方法，beanFactory后置处理器 invokeBeanFactoryPostProcessors(beanFactory); //6.注册BeanPostProcessors，bean后置处理器 registerBeanPostProcessors(beanFactory); //7.初始化MessageSource组件（做国际化功能；消息绑定，消息解析） initMessageSource(); //8.初始化事件派发器，在注册监听器时会用到 initApplicationEventMulticaster(); //9.留给子容器（子类），子类重写这个方法，在容器刷新的时候可以自定义逻辑，web场景下会使用 onRefresh(); //10.注册监听器，派发之前步骤产生的一些事件（可能没有） registerListeners(); //11.初始化所有的非单实例bean finishBeanFactoryInitialization(beanFactory); //12.发布容器刷新完成事件 finishRefresh(); } ... }}首先我们总结一下refresh()方法每一步主要的功能：之后再对每一步的源码做具体的分析
1、prepareRefresh()刷新前的预处理：（1）initPropertySources()：初始化一些属性设置，子类自定义个性化的属性设置方法；（2）getEnvironment().validateRequiredProperties()：检验属性的合法性（3）earlyApplicationEvents=newLinkedHashSetApplicationEvent()：保存容器中的一些早期的事件；2、obtainFreshBeanFactory()：获取在容器初始化时创建的BeanFactory：（1）refreshBeanFactory()：刷新BeanFactory，设置序列化ID；（2）getBeanFactory()：返回初始化中的GenericApplicationContext创建的BeanFactory对象，即类型3、prepareBeanFactory(beanFactory)：BeanFactory的预处理工作，向容器中添加一些组件：（1）设置BeanFactory的类加载器、设置表达式解析器等等（2）添加BeanPostProcessor（3）设置忽略自动装配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware；（4）注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext（5）添加BeanPostProcessor（6）添加编译时的AspectJ；（7）给BeanFactory中注册的3个组件：environment、systemProperties、systemEnvironment4、postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在BeanFactory创建并预处理完成以后做进一步的设置5、invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory标准初始化之后执行BeanFactoryPostProcessor的方法，即BeanFactory的后置处理器：（1）先执行BeanDefinitionRegistryPostProcessor：postProcessor.postProcessBeanDefinitionRegistry(registry)①获取所有的实现了BeanDefinitionRegistryPostProcessor接口类型的集合②先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor③再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor④最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors（2）再执行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)①获取所有的实现了BeanFactoryPostProcessor接口类型的集合②先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor③再执行实现了Ordered顺序接口的BeanFactoryPostProcessor④最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor6、registerBeanPostProcessors(beanFactory)：向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能（1）获取所有实现了BeanPostProcessor接口类型的集合：（2）先注册实现了PriorityOrdered优先级接口的BeanPostProcessor；（3）再注册实现了Ordered优先级接口的BeanPostProcessor；（4）最后注册没有实现任何优先级接口的BeanPostProcessor；（5）最refresh主要可划分为12个步骤，其中比较重要的步骤下面会有详细说明。Spring中的每一个容器都会调用refresh()方法进行刷新，无论是Spring的父子容器，还是SpringCloudFeign中的feign隔离容器，每一个容器都会调用这个方法完成初始化。终注册MergedBeanDefinitionPostProcessor类型的BeanPostProcessor：beanFactory.addBeanPostProcessor(postProcessor);（6）给容器注册一个ApplicationListenerDetector：用于在Bean创建完成后检查是否是ApplicationListener，如果是，就把Bean放到容器中保存起来：applicationContext.addApplicationListener((ApplicationListener?)bean);此时容器中默认有6个默认的BeanProcessor(无任何代理模式下)：、、、、、7、initMessageSource()：初始化MessageSource组件，主要用于做国际化功能，消息绑定与消息解析：（1）看BeanFactory容器中是否有id为messageSource并且类型是MessageSource的组件：如果有，直接赋值给messageSource；如果没有，则创建一个DelegatingMessageSource；（2）把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；8、initApplicationEventMulticaster()：初始化事件派发器，在注册监听器时会用到：（1）看BeanFactory容器中是否存在自定义的ApplicationEventMulticaster：如果有，直接从容器中获取；如果没有，则创建一个SimpleApplicationEventMulticaster（2）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件就可以直接自动注入9、onRefresh()：留给子容器、子类重写这个方法，在容器刷新的时候可以自定义逻辑10、registerListeners()：注册监听器：将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件：（1）从容器中拿到所有的ApplicationListener（2）将每个监听器添加到事件派发器中：getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);（3）派发之前步骤产生的事件applicationEvents：getApplicationEventMulticaster().multicastEvent(earlyEvent);11、finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的单实例bean，核心方法是preInstantiateSingletons()，会调用getBean()方法创建对象；（1）获取容器中的所有beanDefinitionName，依次进行初始化和创建对象（2）获取Bean的定义信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象（3）如果Bean满足这三个条件：非抽象的，单实例，非懒加载，则执行单例Bean创建流程：（4）所有Bean都利用getBean()创建完成以后，检查所有的Bean是否为SmartInitializingSingleton接口的，如果是；就执行afterSingletonsInstantiated()；12、finishRefresh()：发布BeanFactory容器刷新完成事件：（1）initLifecycleProcessor()：初始化和生命周期有关的后置处理器：默认从容器中找是否有lifecycleProcessor的组件，如果没有，则创建一个DefaultLifecycleProcessor()加入到容器；（2）getLifecycleProcessor().onRefresh()：拿到前面定义的生命周期处理器（LifecycleProcessor）回调onRefresh()方法（3）publishEvent(newContextRefreshedEvent(this))：发布容器刷新完成事件；（4）liveBeansView.registerApplicationContext(this);
2、第三步：BeanFactory的预处理：org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory：
这一步主要为beanFactory工厂添加一些内置组件
protectedvoidprepareBeanFactory(ConfigurableListableBeanFactorybeanFactory){ //设置classLoader beanFactory.setBeanClassLoader(getClassLoader()); //设置bean表达式解析器 beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); beanFactory.addPropertyEditorRegistrar(newResourceEditorRegistrar(this,getEnvironment())); //添加一个BeanPostProcessor beanFactory.addBeanPostProcessor(newApplicationContextAwareProcessor(this)); //设置忽略自动装配的接口，即不能通过注解自动注入 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); //注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入 beanFactory.registerResolvableDependency(BeanFactory.class,beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class,this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class,this); beanFactory.registerResolvableDependency(ApplicationContext.class,this); //添加一个BeanPostProcessor beanFactory.addBeanPostProcessor(newApplicationListenerDetector(this)); //添加编译时的AspectJ if(beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)){ beanFactory.addBeanPostProcessor(newLoadTimeWeaverAwareProcessor(beanFactory)); //SetatemporaryClassLoaderfortypematching. beanFactory.setTempClassLoader(newContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } //注册environment组件，类型是 if(!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)){ beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME,getEnvironment()); } //注册systemProperties组件，类型是 if(!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)){ beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME,getEnvironment().getSystemProperties()); } //注册systemEnvironment组件，类型是 if(!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)){ beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME,getEnvironment().getSystemEnvironment()); }}执行流程小结：（1）设置BeanFactory的类加载器、设置表达式解析器等等（2）添加BeanPostProcessor（3）设置忽略自动装配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware；（4）注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext（5）添加BeanPostProcessor（6）添加编译时的AspectJ；（7）给BeanFactory中注册的3个组件：environment、systemProperties、systemEnvironment
3、第五步：执行BeanFactory的后置处理器：org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors：
Spring在扫描完所有的bean转成BeanDefinition时候，允许我们做一些自定义操作，这得益于Spring为我们提供的BeanFactoryPostProcessor接口。
其中BeanFactoryPostProcessor又有一个子接口BeanDefinitionRegistryPostProcessor，前者会把ConfigurableListableBeanFactory暴露给我们使用，后者会把BeanDefinitionRegistry注册器暴露给我们使用，一旦获取到注册器，我们就可以按需注入了。
同时Spring是允许我们控制同类型组件的顺序，比如在AOP中我们常用的
Order注解，这里的BeanFactoryPostProcessor接口当然也是提供了顺序，最先被执行的是实现了PriorityOrdered接口的实现类，然后再到实现了Ordered接口的实现类，最后就是剩下来的常规BeanFactoryPostProcessor类。此时再看上图，是不是发现和喝水一般简单，首先会回调postProcessBeanDefinitionRegistry()方法，然后再回调postProcessBeanFactory()方法，最后注意顺序即可，下面一起看看具体的代码实现吧。
publicstaticvoidinvokeBeanFactoryPostProcessors( ConfigurableListableBeanFactorybeanFactory,ListBeanFactoryPostProcessorbeanFactoryPostProcessors){ //beanFactoryPostProcessors这个参数是指用户通过AnnotationConfigApplicationContext.addBeanFactoryPostProcessor()方法手动传入的BeanFactoryPostProcessor，没有交给spring管理 //InvokeBeanDefinitionRegistryPostProcessorsfirst,ifany. //代表执行过的BeanDefinitionRegistryPostProcessor SetStringprocessedBeans=newHashSet(); if(beanFactoryinstanceofBeanDefinitionRegistry){ BeanDefinitionRegistryregistry=(BeanDefinitionRegistry)beanFactory; //常规后置处理器集合，即实现了BeanFactoryPostProcessor接口 ListBeanFactoryPostProcessorregularPostProcessors=newArrayList(); //注册后置处理器集合，即实现了BeanDefinitionRegistryPostProcessor接口 ListBeanDefinitionRegistryPostProcessorregistryProcessors=newArrayList(); //处理自定义的beanFactoryPostProcessors（指调用context.addBeanFactoryPostProcessor()方法），一般这里都没有 for(BeanFactoryPostProcessorpostProcessor:beanFactoryPostProcessors){ if(postProcessorinstanceofBeanDefinitionRegistryPostProcessor){ BeanDefinitionRegistryPostProcessorregistryProcessor= (BeanDefinitionRegistryPostProcessor)postProcessor; //调用postProcessBeanDefinitionRegistry方法 registryProcessor.postProcessBeanDefinitionRegistry(registry); registryProcessors.add(registryProcessor); } else{ regularPostProcessors.add(postProcessor); } } //DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans //uninitializedtoletthebeanfactorypost-processorsapplytothem! //SeparatebetweenBeanDefinitionRegistryPostProcessorsthatimplement //PriorityOrdered,Ordered,andtherest. //定义一个变量currentRegistryProcessors，表示当前要处理的BeanFactoryPostProcessors ListBeanDefinitionRegistryPostProcessorcurrentRegistryProcessors=newArrayList(); //First,invoketheBeanDefinitionRegistryPostProcessorsthatimplementPriorityOrdered. //首先，从容器中查找实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor类型，这里只会查找出一个 String[]postProcessorNames= beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false); for(StringppName:postProcessorNames){ //判断是否实现了PriorityOrdered接口 if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){ //添加到currentRegistryProcessors currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class)); //添加到processedBeans，表示已经处理过这个类了 processedBeans.add(ppName); } } //设置排列顺序 sortPostProcessors(currentRegistryProcessors,beanFactory); //添加到registry中 registryProcessors.addAll(currentRegistryProcessors); //执行[postProcessBeanDefinitionRegistry]回调方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry); //将currentRegistryProcessors变量清空，下面会继续用到 currentRegistryProcessors.clear(); //Next,invoketheBeanDefinitionRegistryPostProcessorsthatimplementOrdered. //接下来，从容器中查找实现了Ordered接口的BeanDefinitionRegistryPostProcessors类型，这里可能会查找出多个 //因为已经完成了postProcessBeanDefinitionRegistry()方法，已经向容器中完成扫描工作，所以容器会有很多个组件 postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false); for(StringppName:postProcessorNames){ //判断processedBeans是否处理过这个类，且是否实现Ordered接口 if(!processedBeans.contains(ppName)beanFactory.isTypeMatch(ppName,Ordered.class)){ currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } //设置排列顺序 sortPostProcessors(currentRegistryProcessors,beanFactory); //添加到registry中 registryProcessors.addAll(currentRegistryProcessors); //执行[postProcessBeanDefinitionRegistry]回调方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry); //将currentRegistryProcessors变量清空，下面会继续用到 currentRegistryProcessors.clear(); //Finally,invokeallotherBeanDefinitionRegistryPostProcessorsuntilnofurtheronesappear. //最后，从容器中查找剩余所有常规的BeanDefinitionRegistryPostProcessors类型 booleanreiterate=true; while(reiterate){ reiterate=false; //根据类型从容器中查找 postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false); for(StringppName:postProcessorNames){ //判断processedBeans是否处理过这个类 if(!processedBeans.contains(ppName)){ //添加到currentRegistryProcessors currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class)); //添加到processedBeans，表示已经处理过这个类了 processedBeans.add(ppName); //将标识设置为true，继续循环查找，可能随时因为防止下面调用了invokeBeanDefinitionRegistryPostProcessors()方法引入新的后置处理器 reiterate=true; } } //设置排列顺序 sortPostProcessors(currentRegistryProcessors,beanFactory); //添加到registry中 registryProcessors.addAll(currentRegistryProcessors); //执行[postProcessBeanDefinitionRegistry]回调方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry); //将currentRegistryProcessors变量清空，因为下一次循环可能会用到 currentRegistryProcessors.clear(); } //Now,invokethepostProcessBeanFactorycallbackofallprocessorshandledsofar. //现在执行registryProcessors的[postProcessBeanFactory]回调方法 invokeBeanFactoryPostProcessors(registryProcessors,beanFactory); //执行regularPostProcessors的[postProcessBeanFactory]回调方法，也包含用户手动调用addBeanFactoryPostProcessor()方法添加的BeanFactoryPostProcessor invokeBeanFactoryPostProcessors(regularPostProcessors,beanFactory); } else{ //Invokefactoryprocessorsregisteredwiththecontextinstance. invokeBeanFactoryPostProcessors(beanFactoryPostProcessors,beanFactory); } //DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans //uninitializedtoletthebeanfactorypost-processorsapplytothem! //从容器中查找实现了BeanFactoryPostProcessor接口的类 String[]postProcessorNames= beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class,true,false); //SeparatebetweenBeanFactoryPostProcessorsthatimplementPriorityOrdered, //Ordered,andtherest. //表示实现了PriorityOrdered接口的BeanFactoryPostProcessor ListBeanFactoryPostProcessorpriorityOrderedPostProcessors=newArrayList(); //表示实现了Ordered接口的BeanFactoryPostProcessor ListStringorderedPostProcessorNames=newArrayList(); //表示剩下来的常规的BeanFactoryPostProcessors ListStringnonOrderedPostProcessorNames=newArrayList(); for(StringppName:postProcessorNames){ //判断是否已经处理过，因为postProcessorNames其实包含了上面步骤处理过的BeanDefinitionRegistry类型 if(processedBeans.contains(ppName)){ //skip-alreadyprocessedinfirstphaseabove } //判断是否实现了PriorityOrdered接口 elseif(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){ priorityOrderedPostProcessors.add(beanFactory.getBean(ppName,BeanFactoryPostProcessor.class)); } //判断是否实现了Ordered接口 elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){ orderedPostProcessorNames.add(ppName); } //剩下所有常规的 else{ nonOrderedPostProcessorNames.add(ppName); } } //First,invoketheBeanFactoryPostProcessorsthatimplementPriorityOrdered. //先将priorityOrderedPostProcessors集合排序 sortPostProcessors(priorityOrderedPostProcessors,beanFactory); //执行priorityOrderedPostProcessors的[postProcessBeanFactory]回调方法 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors,beanFactory); //Next,invoketheBeanFactoryPostProcessorsthatimplementOrdered. //接下来，把orderedPostProcessorNames转成orderedPostProcessors集合 ListBeanFactoryPostProcessororderedPostProcessors=newArrayList(); for(StringpostProcessorName:orderedPostProcessorNames){ orderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class)); } //将orderedPostProcessors集合排序 sortPostProcessors(orderedPostProcessors,beanFactory); //执行orderedPostProcessors的[postProcessBeanFactory]回调方法 invokeBeanFactoryPostProcessors(orderedPostProcessors,beanFactory); //Finally,invokeallotherBeanFactoryPostProcessors. //最后把nonOrderedPostProcessorNames转成nonOrderedPostProcessors集合，这里只有一个，myBeanFactoryPostProcessor ListBeanFactoryPostProcessornonOrderedPostProcessors=newArrayList(); for(StringpostProcessorName:nonOrderedPostProcessorNames){ nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName,BeanFactoryPostProcessor.class)); } //执行nonOrderedPostProcessors的[postProcessBeanFactory]回调方法 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors,beanFactory); //Clearcachedmergedbeandefinitionssincethepost-processorsmighthave //modifiedtheoriginalmetadata,e.g.replacingplaceholdersinvalues... //清除缓存 beanFactory.clearMetadataCache();}执行流程小结：（1）先执行BeanDefinitionRegistryPostProcessor：postProcessor.postProcessBeanDefinitionRegistry(registry)①获取所有的实现了BeanDefinitionRegistryPostProcessor接口类型的集合②先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor③再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor④最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors（2）再执行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)①获取所有的实现了BeanFactoryPostProcessor接口类型的集合②先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor③再执行实现了Ordered顺序接口的BeanFactoryPostProcessor④最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor
4、第六步：注册Bean的后置处理器：org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors：
这一步是向容器中注入BeanPostProcessor后置处理器，注意这里仅仅是向容器中注入而非使用。关于BeanPostProcessor，它的作用主要是会干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等各种功能。
publicstaticvoidregisterBeanPostProcessors( ConfigurableListableBeanFactorybeanFactory,AbstractApplicationContextapplicationContext){ //从容器中获取BeanPostProcessor类型 String[]postProcessorNames=beanFactory.getBeanNamesForType(BeanPostProcessor.class,true,false); //RegisterBeanPostProcessorCheckerthatlogsaninfomessagewhen //abeaniscreatedduringBeanPostProcessorinstantiation,i.e.when //abeanisnoteligibleforgettingprocessedbyallBeanPostProcessors. intbeanProcessorTargetCount=beanFactory.getBeanPostProcessorCount()+1+postProcessorNames.length; //向容器中添加，主要是用来检查是不是有bean已经初始化完成了， //如果没有执行所有的beanPostProcessor（用数量来判断），如果有就会打印一行info日志 beanFactory.addBeanPostProcessor(newBeanPostProcessorChecker(beanFactory,beanProcessorTargetCount)); //SeparatebetweenBeanPostProcessorsthatimplementPriorityOrdered, //Ordered,andtherest. //存放实现了PriorityOrdered接口的BeanPostProcessor ListBeanPostProcessorpriorityOrderedPostProcessors=newArrayList(); //存放MergedBeanDefinitionPostProcessor类型的BeanPostProcessor ListBeanPostProcessorinternalPostProcessors=newArrayList(); //存放实现了Ordered接口的BeanPostProcessor的name ListStringorderedPostProcessorNames=newArrayList(); //存放剩下来普通的BeanPostProcessor的name ListStringnonOrderedPostProcessorNames=newArrayList(); //从beanFactory中查找postProcessorNames里的bean，然后放到对应的集合中 for(StringppName:postProcessorNames){ //判断有无实现PriorityOrdered接口 if(beanFactory.isTypeMatch(ppName,PriorityOrdered.class)){ BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); //如果实现了PriorityOrdered接口，且属于MergedBeanDefinitionPostProcessor if(ppinstanceofMergedBeanDefinitionPostProcessor){ //把MergedBeanDefinitionPostProcessor类型的添加到internalPostProcessors集合中 internalPostProcessors.add(pp); } } elseif(beanFactory.isTypeMatch(ppName,Ordered.class)){ orderedPostProcessorNames.add(ppName); } else{ nonOrderedPostProcessorNames.add(ppName); } } //First,registertheBeanPostProcessorsthatimplementPriorityOrdered. //给priorityOrderedPostProcessors排序 sortPostProcessors(priorityOrderedPostProcessors,beanFactory); //先注册实现了PriorityOrdered接口的beanPostProcessor registerBeanPostProcessors(beanFactory,priorityOrderedPostProcessors); //Next,registertheBeanPostProcessorsthatimplementOrdered. //从beanFactory中查找orderedPostProcessorNames里的bean，然后放到对应的集合中 ListBeanPostProcessororderedPostProcessors=newArrayList(); for(StringppName:orderedPostProcessorNames){ BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class); orderedPostProcessors.add(pp); if(ppinstanceofMergedBeanDefinitionPostProcessor){ internalPostProcessors.add(pp); } } //给orderedPostProcessors排序 sortPostProcessors(orderedPostProcessors,beanFactory); //再注册实现了Ordered接口的beanPostProcessor registerBeanPostProcessors(beanFactory,orderedPostProcessors); //Now,registerallregularBeanPostProcessors. ListBeanPostProcessornonOrderedPostProcessors=newArrayList(); for(StringppName:nonOrderedPostProcessorNames){ BeanPostProcessorpp=beanFactory.getBean(ppName,BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if(ppinstanceofMergedBeanDefinitionPostProcessor){ internalPostProcessors.add(pp); } } //再注册常规的beanPostProcessor registerBeanPostProcessors(beanFactory,nonOrderedPostProcessors); //Finally,re-registerallinternalBeanPostProcessors. //排序MergedBeanDefinitionPostProcessor这种类型的beanPostProcessor sortPostProcessors(internalPostProcessors,beanFactory); //最后注册MergedBeanDefinitionPostProcessor类型的beanPostProcessor registerBeanPostProcessors(beanFactory,internalPostProcessors); //Re-registerpost-processorfordetectinginnerbeansasApplicationListeners, //movingittotheendoftheprocessorchain(forpickingupproxiesetc). //给容器中添加beanPostProcessor，判断是不是监听器，如果是就把bean放到容器中保存起来 //此时容器中默认会有6个内置的beanPostProcessor //0={ApplicationContextAwareProcessor
} // 1={ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor} // 2={PostProcessorRegistrationDelegate$BeanPostProcessorChecker} // 3={CommonAnnotationBeanPostProcessor} // 4={AutowiredAnnotationBeanPostProcessor} // 5={ApplicationListenerDetector} beanFactory.addBeanPostProcessor(newApplicationListenerDetector(applicationContext));}执行流程小结：（1）获取所有实现了BeanPostProcessor接口类型的集合：（2）先注册实现了PriorityOrdered优先级接口的BeanPostProcessor；（3）再注册实现了Ordered优先级接口的BeanPostProcessor；（4）最后注册没有实现任何优先级接口的BeanPostProcessor；（5）最终注册MergedBeanDefinitionPostProcessor类型的BeanPostProcessor；（6）给容器注册一个ApplicationListenerDetector：用于在Bean创建完成后检查是否是ApplicationListener，如果是，就把Bean放到容器中保存起来：applicationContext.addApplicationListener((ApplicationListener?)bean);5、第八步：初始化事件派发器：org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster：
前文我们说到，在整个容器创建过程中，Spring会发布很多容器事件，如容器启动、刷新、关闭等，这个功能的实现得益于这里的ApplicationEventMulticaster广播器组件，通过它来派发事件通知。
protectedvoidinitApplicationEventMulticaster(){ //获取beanFactory ConfigurableListableBeanFactorybeanFactory=getBeanFactory(); //看看容器中是否有自定义的applicationEventMulticaster if(beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)){ //有就从容器中获取赋值 this.applicationEventMulticaster= beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,ApplicationEventMulticaster.class); if(logger.isTraceEnabled()){ logger.trace(UsingApplicationEventMulticaster[+this.applicationEventMulticaster+]); } } else{ //没有，就创建一个SimpleApplicationEventMulticaster this.applicationEventMulticaster=newSimpleApplicationEventMulticaster(beanFactory); //将创建的ApplicationEventMulticaster添加到BeanFactory中，其他组件就可以自动注入了 beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME,this.applicationEventMulticaster); if(logger.isTraceEnabled()){ logger.trace(No+APPLICATION_EVENT_MULTICASTER_BEAN_NAME+bean,using+ [+this.applicationEventMulticaster.getClass().getSimpleName()+]); } }}执行流程小结：（1）看BeanFactory容器中是否存在自定义的ApplicationEventMulticaster：如果有，直接从容器中获取；如果没有，则创建一个SimpleApplicationEventMulticaster（2）将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件就可以直接自动注入
6、第十步：注册ApplicationListener监听器：org.springframework.context.support.AbstractApplicationContext#registerListeners：
这一步主要是将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件。
protectedvoidregisterListeners(){ //Registerstaticallyspecifiedlistenersfirst. //获取之前步骤中保存的ApplicationListener for(ApplicationListener?listener:getApplicationListeners()){ //getApplicationEventMulticaster()就是获取之前步骤初始化的applicationEventMulticaster getApplicationEventMulticaster().addApplicationListener(listener); } //DonotinitializeFactoryBeanshere:Weneedtoleaveallregularbeans //uninitializedtoletpost-processorsapplytothem! //从容器中获取所有的ApplicationListener String[]listenerBeanNames=getBeanNamesForType(ApplicationListener.class,true,false); for(StringlistenerBeanName:listenerBeanNames){ getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } //Publishearlyapplicationeventsnowthatwefinallyhaveamulticaster... //派发之前步骤产生的applicationevents SetApplicationEventearlyEventsToProcess=this.earlyApplicationEvents; this.earlyApplicationEvents=null; if(earlyEventsToProcess!=null){ for(ApplicationEventearlyEvent:earlyEventsToProcess){ getApplicationEventMulticaster().multicastEvent(earlyEvent); } }}执行流程小结：（1）从容器中拿到所有的ApplicationListener（2）将每个监听器添加到事件派发器中：getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);（3）派发之前步骤产生的事件applicationEvents：getApplicationEventMulticaster().multicastEvent(earlyEvent);
7、第十一步：初始化所有的单例Bean：org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons：
在前面的步骤中，Spring的大多数组件都已经初始化完毕了，剩下来的这个步骤就是初始化所有剩余的单实例bean，Spring主要是通过preInstantiateSingletons()方法把容器中的bean都初始化完毕。这里我们就不细讲Bean的创建流程了。
publicvoidpreInstantiateSingletons()throwsBeansException{ if(logger.isTraceEnabled()){ logger.trace(Pre-instantiatingsingletonsin+this); } //Iterateoveracopytoallowforinitmethodswhichinturnregisternewbeandefinitions. //Whilethismaynotbepartoftheregularfactorybootstrap,itdoesotherwiseworkfine. //获取容器中的所有beanDefinitionName ListStringbeanNames=newArrayList(this.beanDefinitionNames); //Triggerinitializationofallnon-lazysingletonbeans... //循环进行初始化和创建对象 for(StringbeanName:beanNames){ //获取RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象 RootBeanDefinitionbd=getMergedLocalBeanDefinition(beanName); //如果是非抽象的，且单实例，非懒加载 if(!bd.isAbstract()bd.isSingleton()!bd.isLazyInit()){ //如果是factoryBean，利用下面这种方法创建对象 if(isFactoryBean(beanName)){ //如果是factoryBean，则加上，先创建工厂bean Objectbean=getBean(FACTORY_BEAN_PREFIX+beanName); if(beaninstanceofFactoryBean){ finalFactoryBean?factory=(FactoryBean?)bean; booleanisEagerInit; if(System.getSecurityManager()!=nullfactoryinstanceofSmartFactoryBean){ isEagerInit=AccessController.doPrivileged((PrivilegedActionBoolean) ((SmartFactoryBean?)factory)::isEagerInit, getAccessControlContext()); } else{ isEagerInit=(factoryinstanceofSmartFactoryBean ((SmartFactoryBean?)factory).isEagerInit()); } if(isEagerInit){ getBean(beanName); } } } else{ //不是工厂bean，用这种方法创建对象 getBean(beanName); } } } //Triggerpost-initializationcallbackforallapplicablebeans... for(StringbeanName:beanNames){ ObjectsingletonInstance=getSingleton(beanName); //检查所有的bean是否是SmartInitializingSingleton接口 if(singletonInstanceinstanceofSmartInitializingSingleton){ finalSmartInitializingSingletonsmartSingleton=(SmartInitializingSingleton)singletonInstance; if(System.getSecurityManager()!=null){ AccessController.doPrivileged((PrivilegedActionObject)()-{ smartSingleton.afterSingletonsInstantiated(); returnnull; },getAccessControlContext()); } else{ //回调afterSingletonsInstantiated()方法，可以在回调中做一些事情 smartSingleton.afterSingletonsInstantiated(); } } }}执行流程小结：（1）获取容器中的所有beanDefinitionName，依次进行初始化和创建对象（2）获取Bean的定义信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象（3）如果Bean满足这三个条件：非抽象的，单实例，非懒加载，则执行单例Bean创建流程：（4）所有Bean都利用getBean()创建完成以后，检查所有的Bean是否为SmartInitializingSingleton接口的，如果是；就执行afterSingletonsInstantiated()；
8、第十二步：发布BeanFactory容器刷新完成事件：org.springframework.context.support.AbstractApplicationContext#finishRefresh：
整个容器初始化完毕之后，会在这里进行一些扫尾工作，如清理缓存，初始化生命周期处理器，发布容器刷新事件等。
protectedvoidfinishRefresh(){ //Clearcontext-levelresourcecaches(suchasASMmetadatafromscanning). //清理缓存 clearResourceCaches(); //Initializelifecycleprocessorforthiscontext. //初始化和生命周期有关的后置处理器 initLifecycleProcessor(); //Propagaterefreshtolifecycleprocessorfirst. //拿到前面定义的生命周期处理器回调onRefresh()方法 getLifecycleProcessor().onRefresh(); //Publishthefinalevent. //发布容器刷新完成事件 publishEvent(newContextRefreshedEvent(this)); //ParticipateinLiveBeansViewMBean,ifactive. LiveBeansView.registerApplicationContext(this);}执行流程小结：（1）initLifecycleProcessor()：初始化和生命周期有关的后置处理器：默认从容器中找是否有lifecycleProcessor的组件，如果没有，则创建一个DefaultLifecycleProcessor()加入到容器；（2）getLifecycleProcessor().onRefresh()：拿到前面定义的生命周期处理器（LifecycleProcessor）回调onRefresh()方法（3）publishEvent(newContextRefreshedEvent(this))：发布容器刷新完成事件；（4）liveBeansView.registerApplicationContext(this);
