本文共 54624 字，大约阅读时间需要 182 分钟。
我们以测试类中的这行代码为入口，来一起看一下Spring注解下是如何初始化IOC容器的。
ApplicationContext ioc = new AnnotationConfigApplicationContext(xxxConfig.class);
AnnotationConfigApplicationContext是Spring注解模式下的应用上下文对象，当我们创建IOC容器时，会首先调用该类的构造方法来执行初始化操作。
public AnnotationConfigApplicationContext(Class ... componentClasses) { this(); // 位置1 register(componentClasses); refresh();} 可以看到无参构造中主要初始化了注解下Bean定义阅读器（AnnotatedBeanDefinitionReader）及类路径下Bean定义的扫描器（ClassPathBeanDefinitionScanner）。
// AnnotationConfigApplicationContext 的无参构造public AnnotationConfigApplicationContext() { StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create"); this.reader = new AnnotatedBeanDefinitionReader(this); //位置1 createAnnotatedBeanDefReader.end(); // 一个bean定义的扫描器，用来扫描类路径上的bean，主要是Spring在初始化早期提供给我们使用 this.scanner = new ClassPathBeanDefinitionScanner(this);} 注：StartupStep（DefaultApplicationStartup）用来标记容器初始化过程中的执行步骤。
我们来一起看一下AnnotationConfigApplicationContext调用构造方法 this() 时都做了什么（上步骤代码位置1）：
首先进入 AnnotatedBeanDefinitionReader 的构造方法：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) { this(registry, getOrCreateEnvironment(registry));} 可以看到内部调用了另外一个有参构造：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); //位置1 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);} 继续深入位置1：
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) { registerAnnotationConfigProcessors(registry, null);}public static Set registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); if (beanFactory != null) { if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); } if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); } } Set beanDefs = new LinkedHashSet<>(8); if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(); try { def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, AnnotationConfigUtils.class.getClassLoader())); } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex); } def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)); } return beanDefs;} 通过上面这个方法 registerAnnotationConfigProcessors() ，完成了第一步对一些系统级处理器的注册，他们的id和name分别如下所示：
org.springframework.context.annotation.internalConfigurationAnnotationProcessor org.springframework.context.annotation.ConfigurationClassPostProcessor // BeanDefinitionRegistryPostProcessor实现类 org.springframework.context.event.internalEventListenerFactory org.springframework.context.event.DefaultEventListenerFactory org.springframework.context.event.internalEventListenerProcessor org.springframework.context.event.EventListenerMethodProcessor // BeanFactoryPostProcessor 实现类 org.springframework.context.annotation.internalAutowiredAnnotationProcessor org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor // BeanPostProcessor org.springframework.context.annotation.internalCommonAnnotationProcessor org.springframework.context.annotation.CommonAnnotationBeanPostProcessor // BeanPostProcessor
接下来的流程中我们会提到这些组件在初始化流程中的使用。
从上一步我们知道，在 this() 中初始化了 AnnotatedBeanDefinitionReader，这一步就是使用这个AnnotatedBeanDefinitionReader来将我们传入的配置类xxxConfig.class 注册到BeanFactory
@Overridepublic void register(Class ... componentClasses) { Assert.notEmpty(componentClasses, "At least one component class must be specified"); StartupStep registerComponentClass = this.getApplicationStartup().start("spring.context.component-classes.register") .tag("classes", () -> Arrays.toString(componentClasses)); // 注册配置类 this.reader.register(componentClasses); registerComponentClass.end();}// AnnotatedBeanDefinitionReader中的register()方法public void register(Class ... componentClasses) { for (Class componentClass : componentClasses) { registerBean(componentClass); // 注册配置类 }} 如上代码所示，register() 方法通过 AnnotatedBeanDefinitionReader 将我们传入的一个或多个配置类注册到Bean定义中。
经过一、二两个步骤的处理，Spring将前期初始化需要用到的一些组件和我们的配置类就加入到了Bean定义信息中。
AbstractApplicationContext.refresh() 方法内容如下：
@Overridepublic void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // 记录步骤信息 StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); // 准备工作 prepareRefresh(); // 初始化BeanDefinition并获取beanFactory ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 准备BeanFactory 的一些内容 prepareBeanFactory(beanFactory); try { // 模版方法，我们可以通过子类实现BeanFactory后置处理 postProcessBeanFactory(beanFactory); // 记录步骤信息 StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); // 调用BeanFactory后置处理 invokeBeanFactoryPostProcessors(beanFactory); // 注册Bean的后置处理器 registerBeanPostProcessors(beanFactory); beanPostProcess.end(); // Initialize message source for this context. initMessageSource(); // 初始化上下文事件派发器 initApplicationEventMulticaster(); // 模版方法 onRefresh(); // 注册监听器 registerListeners(); // 初始化剩下的单实例Bean finishBeanFactoryInitialization(beanFactory); // 发布完成事件等操作 finishRefresh(); } catch (BeansException ex) { // 异常处理... } finally { resetCommonCaches(); contextRefresh.end(); } }} 接下来我们在后续的步骤中一步步看里面做了什么操作。
进行IOC初始化前的一些准备工作，如：初始化容器状态、设置启动时间等操作
protected void prepareRefresh() { this.startupDate = System.currentTimeMillis();// 设置启动时间 this.closed.set(false); // 设置初始化状态 this.active.set(true); if (logger.isDebugEnabled()) { if (logger.isTraceEnabled()) { logger.trace("Refreshing " + this); } else { logger.debug("Refreshing " + getDisplayName()); } } // 模版方法 初始化一些属性设置，子类自定义个性化的属性设置方法 initPropertySources(); // 校验属性合法性等 getEnvironment().validateRequiredProperties(); if (this.earlyApplicationListeners == null) { this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners); } else { this.applicationListeners.clear(); this.applicationListeners.addAll(this.earlyApplicationListeners); } // 初始化早期事件 this.earlyApplicationEvents = new LinkedHashSet<>();} protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { refreshBeanFactory(); return getBeanFactory();} 该方法用来刷新BeanFactory, 源码如下
// GenericApplicationContext 中的 refreshBeanFactory() @Overrideprotected final void refreshBeanFactory() throws IllegalStateException { // 设置刷新状态 if (!this.refreshed.compareAndSet(false, true)) { // 更新状态失败则抛出异常 throw new IllegalStateException( "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once"); } // 设置当前BeanFactory的序列化id this.beanFactory.setSerializationId(getId());} 返回刚才设置好状态的BeanFactory。
备注：创建GenericApplicationContext时，会初始化Bean工厂（DefaultListableBeanFactory）。
public GenericApplicationContext() { this.beanFactory = new DefaultListableBeanFactory();} 该步骤主要是用来准备我们需要使用的Bean工厂。
源码如下：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // 设置类加载器 beanFactory.setBeanClassLoader(getClassLoader()); if (!shouldIgnoreSpel) { // 设置spel表达式解析器 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); } beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // 添加Bean后置处理器【ApplicationContextAwareProcessor】 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); // 设置忽略自动装配的接口EnvironmentAware等 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.ignoreDependencyInterface(ApplicationStartupAware.class); // 注册可以解析的自动装配，我们能直接在任何组件中自动注入 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); // 添加BeanPostProcessor 【ApplicationListenerDetector】 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // 添加编译时的AspectJ if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // 注册默认组件Environment，systemProperties等 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) { beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup()); }} 模版方法，子类通过重写这个方法在BeanFactory创建并预准备完成之后做一些设置。（模版方法模式）
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { } 该方法主要目的是在BeanFactory标准初始化执行之后执行。前面我们知道：
该方法的目的就是，帮助我们调用实现了这两个接口的类实现的方法。
来看该方法的内部：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { // 位置1 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // AOP 相关 if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); }} 可以看到，这里由 PostProcessorRegistrationDelegate 的invokeBeanFactoryPostProcessors() 方法执行调用逻辑，继续进来：
public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, ListbeanFactoryPostProcessors) { Set processedBeans = new HashSet<>(); if (beanFactory instanceof BeanDefinitionRegistry) { ... // 创建集合存储 List currentRegistryProcessors = new ArrayList<>(); // 位置1 // 1，首先创建实现了优先级接口的PriorityOrdered的BeanDefinitionRegistryPostProcessors实现类 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } // 2，排序 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); // 调用 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); currentRegistryProcessors.clear(); ... ...}
只贴出了一部分方法代码，我们来着重看一下位置1的这一部分代码：
首先，使用 getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false) 从beanFactory中获取 BeanDefinitionRegistryPostProcessor 的实现类。
我们知道在整个IOC初始化调用this()【步骤一】时，注册了五个组件，其中一个 ConfigurationClassPostProcessor 就是 BeanDefinitionRegistryPostProcessor 的实现类：
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware { ... } ConfigurationClassPostProcessor 实现了 优先级接口 PriorityOrdered ，且配置优先级为最低：
@Overridepublic int getOrder() { return Ordered.LOWEST_PRECEDENCE; // Integer.MAX_VALUE} 又因为此时容器中只有5个系统级组件和我们的配置类，因此这里获取实现类时会获取到容器中的 ConfigurationClassPostProcessor 。当然，如果你传入的配置类也是 BeanDefinitionRegistryPostProcessor 的子类且实现了优先级接口，那么从这里也能获取到。
由 sortPostProcessors() 方法针对获取到的实现类优先级进行排序（getOrder()的返回值）
invokeBeanDefinitionRegistryPostProcessors() 调用获取到的Processors【实现类】：
private static void invokeBeanDefinitionRegistryPostProcessors( Collection postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) { // 循环调用所有的postProcessor for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) { StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process") .tag("postProcessor", postProcessor::toString); // 位置1：调用方法 postProcessor.postProcessBeanDefinitionRegistry(registry); postProcessBeanDefRegistry.end(); }} 可以看到这里传入的是我们获取的所有processor，然后循环调用所有 BeanDefinitionRegistryPostProcessor 实现类的 postProcessBeanDefinitionRegistry(registry) 方法
以上流程就是在 invokeBeanFactoryPostProcessors() 中首先调用所有实现了 BeanDefinitionRegistryPostProcessor 接口的实现类的 postProcessBeanDefinitionRegistry() 方法的大致流程。接下来我们来着重看一下Spring提供的一个Processor：ConfigurationClassPostProcessor 在此时是如何工作的：
在上面的循环调用 processor 中，ConfigurationClassPostProcessor 会调用自己的处理逻辑如下：
@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { int registryId = System.identityHashCode(registry); if (this.registriesPostProcessed.contains(registryId)) { throw new IllegalStateException("..."); } if (this.factoriesPostProcessed.contains(registryId)) { throw new IllegalStateException("..."); } this.registriesPostProcessed.add(registryId); // 位置1 processConfigBeanDefinitions(registry);} 位置1：处理配置的bean定义，代码很长只保留如下部分：
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { ... // 获取解析器解析配置类 ConfigurationClassParser parser = new ConfigurationClassParser( this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry); Set candidates = new LinkedHashSet<>(configCandidates); Set alreadyParsed = new HashSet<>(configCandidates.size()); do { StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse"); // 解析 位置1 parser.parse(candidates); parser.validate(); Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses()); configClasses.removeAll(alreadyParsed); // Read the model and create bean definitions based on its content if (this.reader == null) { this.reader = new ConfigurationClassBeanDefinitionReader( registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry()); } // 位置2 this.reader.loadBeanDefinitions(configClasses); alreadyParsed.addAll(configClasses); processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end(); candidates.clear(); if (registry.getBeanDefinitionCount() > candidateNames.length) { String[] newCandidateNames = registry.getBeanDefinitionNames(); Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames)); Set alreadyParsedClasses = new HashSet<>(); for (ConfigurationClass configurationClass : alreadyParsed) { alreadyParsedClasses.add(configurationClass.getMetadata().getClassName()); } for (String candidateName : newCandidateNames) { if (!oldCandidateNames.contains(candidateName)) { BeanDefinition bd = registry.getBeanDefinition(candidateName); if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) && !alreadyParsedClasses.contains(bd.getBeanClassName())) { candidates.add(new BeanDefinitionHolder(bd, candidateName)); } } } candidateNames = newCandidateNames; } } while (!candidates.isEmpty()); ...} 首先来看该方法的第一部分——扫描内部类：
if (configClass.getMetadata().isAnnotated(Component.class.getName())) { processMemberClasses(configClass, sourceClass, filter);} 在该方法中，首先获取该方法的内部类，然后解析。假如有多层内部类，那么就会通过递归调用的方式层层解析。也就是说，假如我们在配置类中书写了内部类且加上了@ComponmentScan等注解，在该方法中会被首先扫描解析，就像下面这样：
@Configurationpublic class TestConfig10 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered { // 该内部类会被优先扫描 @ComponentScan("com.zsp.demo") class TestSubClass { ... }} 接着看方法的第二部分——扫描@PropertySource
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { // 扫描配置类 processPropertySource(propertySource); } else { logger.info("..."); }} 这一步的操作主要使用 processPropertySource() 方法来解析我们 @PropertySource ，并最终将加载的配置文件信息解析到环境变量 environment 的 properySource 中。
接着看第三部分——扫描@ComponentScan
SetcomponentScans = AnnotationConfigUtils.attributesForRepeatable( ... Set scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); ...}
主要看其内部的这个 ComponentScanAnnotationParser 的 parse() 方法：
在这个方法中：
接着看第四部分——扫描@Import
// 扫描 @Import 注解processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
该步骤的目的主要是扫描@import中配置的类
需要注意的是：从@Import，@Bean扫描到的需要注册的Bean并不会在这个方法里直接注册，而是后续在 ConfigurationClassPostProcessor 的 processConfigBeanDefinitions() 中注册。
如果说我们的@Import中传入的不是要注册的组件，而是 ImportBeanDefinitionRegistrar的实现类，那么在后面的处理方式也有不同。
第五部分——扫描@ImportSource：该步骤的目的主要是将@ImportSource配置的xml或其他配置文件解析。
第六部分——解析@Bean
第七：处理接口的默认实现，如果有子类实现了配置接口，则扫描
processInterfaces(configClass, sourceClass);
最后：扫描子类，即如果该配置类存在子类，则扫描
从5.1.1的介绍中我们知道：@Bean和@Import的扫描到需要注册的组件并没有在前面直接注册，而是在 5.1 贴出代码块的位置2执行加载操作：
5.1代码位置2处代码如下：
this.reader.loadBeanDefinitions(configClasses);private void loadBeanDefinitionsForConfigurationClass( ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) { ... for (BeanMethod beanMethod : configClass.getBeanMethods()) { loadBeanDefinitionsForBeanMethod(beanMethod); } loadBeanDefinitionsFromImportedResources(configClass.getImportedResources()); loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());} 该方法主要流程如下：
经过上面的这些处理，我们配置的那些需要注册的组件的Bean定义就已经被加载到容器中。
从5.2我们知道，方法的最后一步是【执行没有实现任何优先级或排序接口的BeanFactoryPostProcessor的postProcessBeanFactory() 方法】，我们通过观察可以知道：EventListenerMethodProcessor 是一个未实现任何优先级接口的 BeanFactoryPostProcessor 实现类（EventListenerMethodProcessor 在this()中已经注册）。因此，在该环节，将会由 EventListenerMethodProcessor 先设置一个默认的监听工厂 DefaultListableBeanFactory 用来后续处理。
总结一下：其实就是优先调用 BeanDefinitionRegistryPostProcessor 接口的实现方法后调用 BeanFactoryPostProcessor的实现方法。
方法源码：
public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); List priorityOrderedPostProcessors = new ArrayList<>(); List internalPostProcessors = new ArrayList<>(); List orderedPostProcessorNames = new ArrayList<>(); List nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // First, register the BeanPostProcessors that implement PriorityOrdered. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // Next, register the BeanPostProcessors that implement Ordered. List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } sortPostProcessors(orderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, orderedPostProcessors); // Now, register all regular BeanPostProcessors. List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // Finally, re-register all internal BeanPostProcessors. sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); // Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc). beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));} 方法步骤：
总结：其实就是将我们容器中的BeanPostProcessor给添加到BeanFactory中（List< BeanPostProcess >）;
private final ListbeanPostProcessors = new BeanPostProcessorCacheAwareList();
源码如下：
protected void initMessageSource() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class); // Make MessageSource aware of parent MessageSource. if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) { HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource; if (hms.getParentMessageSource() == null) { // Only set parent context as parent MessageSource if no parent MessageSource // registered already. hms.setParentMessageSource(getInternalParentMessageSource()); } } if (logger.isTraceEnabled()) { logger.trace("Using MessageSource [" + this.messageSource + "]"); } } else { DelegatingMessageSource dms = new DelegatingMessageSource(); dms.setParentMessageSource(getInternalParentMessageSource()); this.messageSource = dms; beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); if (logger.isTraceEnabled()) { logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]"); } }} 方法步骤：
获取BeanFactory
看容器中是否有id为messageSource，类型是MessageSource的组件
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource
MessageSource：主要用来做国际化功能（消息绑定，解析等），可以取出国际化配置文件中某个key的值，能按照区域信息获取
String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException;
把创建好的MessageSource注册到容器中
该方法的作用是初始化事件派发器。ApplicationEventMulticaster：事件派发器，可以管理大量的ApplicationListener对象并向其发布事件。
源码如下：
protected void initApplicationEventMulticaster() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); // 获取BeanFactory中的事件派发器 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); if (logger.isTraceEnabled()) { logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]"); } } // 如果没有初始化事件派发器，则创建一个SimpleApplicationEventMulticaster else { this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(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() + "]"); } }} 方法步骤：
protected void onRefresh() throws BeansException { // For subclasses: do nothing by default.} 源码如下：
protected void registerListeners() { // Register statically specified listeners first. for (ApplicationListener listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } // 发布早期事件 Set earlyEventsToProcess = this.earlyApplicationEvents; this.earlyApplicationEvents = null; if (!CollectionUtils.isEmpty(earlyEventsToProcess)) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { getApplicationEventMulticaster().multicastEvent(earlyEvent); } }} 方法步骤：
该方法是完成IOC容器初始化之前的最后一步，主要目的是初始化所有剩余的单例bean。方法源码如下所示：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // 如果没有值解析器就先创建一个并添加 注意这里在后面@Value注入时用到 if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // AOP相关 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } beanFactory.setTempClassLoader(null); beanFactory.freezeConfiguration(); // 初始化所有剩余的单例Bean 位置1 beanFactory.preInstantiateSingletons();} 从方法名和前面的流程介绍中我们可以知道：在初始化剩余单例bean之前，一些Spring的组件（派发器、处理器等）和我们定义的一些组件（自定义处理器、配置类）会先被注入到容器中。
代码最后一行（位置1）的方法就是来初始化剩余的单例Bean（非懒加载的）：
// DefaultListableBeanFactory 中@Overridepublic void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // 获取所有的bean定义 List beanNames = new ArrayList<>(this.beanDefinitionNames); // 触发所有非懒加载单例Bean的初始化 for (String beanName : beanNames) { // 根据bean名称获取详细的Bean定义信息 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 如果Bean是单例的，且非懒加载，非抽象 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 判断是否是FactoryBean，即bean如果实现了FactoryBean接口，就会调用getObject()创建对象 if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean factory = (FactoryBean ) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction ) ((SmartFactoryBean ) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean ) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { // 如果不是就在这里初始化 位置1 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize") .tag("beanName", beanName); SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction 上面方法步骤如下：
首先获取所有的bean定义名称，然后遍历
然后根据名称获取具体的bean定义信息
如果bean是单例且非懒加载，非抽象就尝试获取bean
获取bean时，如果bean是FactoryBean的实现类，那么就使用 FactoryBean 的getObject() 方法获取并初始化bean
否则使用 Abstract BeanFactory.getBean(beanName) 获取（位置1），接下来我们一起看一下这个方法：
@Overridepublic Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false);} 该方法调用 doGetBean() 方法获取Bean。
下面来看该方法的源码：
@SuppressWarnings("unchecked")protected T doGetBean(String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 1，转化beanName，可以通过&前缀获取FactoryBean实例 String beanName = transformedBeanName(name); Object beanInstance; // 2，尝试获取单例 位置1 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace(" ... "); } else { logger.trace("..."); } } beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // 如果bean已经被创建则报错 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // ... // 检查父工厂中是否已经注册，存在就返回 // ... } // 将bean标记为准备创建状态 if (!typeCheckOnly) { markBeanAsCreated(beanName); } // 记录步骤信息 StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name); try { if (requiredType != null) { beanCreation.tag("beanType", requiredType::toString); } // 获取Bean定义 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // 如果有依赖的组件，则先去实例化依赖的组件 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(...); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(...); } } } // 创建bean实例 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // 销毁单例 destroySingleton(beanName); throw ex; } }); beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // 如果是多例的，创建一个新的实例 Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new ScopeNotActiveException(beanName, scopeName, ex); } } } catch (BeansException ex) { beanCreation.tag("exception", ex.getClass().toString()); beanCreation.tag("message", String.valueOf(ex.getMessage())); cleanupAfterBeanCreationFailure(beanName); throw ex; } finally { beanCreation.end(); } } return adaptBeanInstance(name, beanInstance, requiredType);} 该方法有以下几个步骤：
首先根据传入的beanName，尝试 getSingleton(beanName) 从缓存中获取（11.1.1步）
如果没有获取到则将bean标记为创建状态
判断要实例化的bean有没有依赖其他的Bean（@DependsOn标注），如果有则先加载依赖的bean，需要注意的是，如果这里出现了A依赖B而B又依赖A，那么将会报错，例子如下：
// 互相依赖@Repository@DependsOn("testService")public class TestDao { }@Service@DependsOn("testDao")public class TestService { } 创建Bean实例（11.1.2步）
如果是多例的，则新建一个bean实例
该方法用于尝试获取完成实例化的bean，代码如下：
@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) { // 检查一级缓存中是否存在该bean Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { synchronized (this.singletonObjects) { singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { ObjectFactory singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } } } return singletonObject;} singletonObjects、earlySingletonObjects、singletonFactories 分别为Spring的三级缓存。
在该方法中，首先从一级缓存中获取；如果获取不到，则从二级缓存中获取，如果二级缓存中也获取不到，那么将会尝试从三级缓存 singletonFactories 中获取。
部分代码省略：
@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { ... // 位置1 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { // 有返回值则返回 return bean; } ... // 创建bean 位置2 Object beanInstance = doCreateBean(beanName, mbdToUse, args); ...} 位置1：提前执行 InstantiationAwareBeanPostProcessor 实现类的处理方法，主要用于阻断Bean实例化进程，自定义我们需要的bean。
位置2：AbstractAutowireCapableBeanFactory.doCreateBean(beanName, mbdToUse, args) 创建Bean
我们来一起看一下这个方法：
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { // 位置1：创建Bean实例 instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // 位置2：处理MergedBeanDefinitionPostProcessor synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException("..."); } mbd.postProcessed = true; } } // 位置3 将早期bean引用添加到三级缓存 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("..."); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } Object exposedObject = bean; try { // 位置4 属性赋值 populateBean(beanName, mbd, instanceWrapper); // 位置5 实例化bean exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { ... } // 最后检查有没有实例化完成 if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException("..."); } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject;} 方法流程：
如果Bean定义中配置了 InstanceSupplier 信息，则使用 instanceSupplier 中配置的方法进行实例化，比如：
@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Color.class); // 配置instanceSupplier rootBeanDefinition.setIinstanceSupplier(Color::new); registry.registerBeanDefinition("color", new RootBeanDefinition(Color.class));} 如果有工厂bean的相关配置，则使用工厂方法创建对象（例如实现了FactoryBean接口）
如果以上两种方式皆否，则寻找最优的构造函数进行初始化
如果没有找到最优的构造函数，则使用默认的构造函数创建bean实例
方法流程：
主要目的：将bean的早期引用添加到三级缓存中（用来解决循环依赖问题）
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { this.singletonFactories.put(beanName, singletonFactory);// 添加到三级缓存 this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } }} protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { ... } // 位置1：在设置之前给 InstantiationAwareBeanPostProcessor 最后一次机会进行后置处理 // 主要是用来修改bean的属性值，如果返回false，那么方法将会返回，不进行后续操作 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) { if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { return; } } } // 如果存在属性定义就获取，不存在就返回空（前面可能设置了属性） PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); // 位置2：获取自动装配的类型：如按类型、按名称装配等，默认为0 int resolvedAutowireMode = mbd.getResolvedAutowireMode(); // 如果是按名称或类型自动装配则进行以下操作 if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs);// 按名称注入 } if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs);// 按类型注入 } pvs = newPvs; } // 是否存在 InstantiationAwareBeanPostProcessor boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); // 返回是否进行依赖项检查（默认false） boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } // 遍历容器中所有 InstantiationAwareBeanPostProcessor // 1,ConfigurationClassPostProcessor // 2,CommonAnnotationBeanPostProcessor(处理@Resource) // 3,AutowiredAnnotationBeanPostProcessor(处理@Autowired，@Value) for ( bp : getBeanPostProcessorCache().instantiationAware) { PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } // 进行依赖检查 checkDependencies(beanName, mbd, filteredPds, pvs); } if (pvs != null) { // 应用给定的属性值 applyPropertyValues(beanName, mbd, bw, pvs); }} 步骤总结：
首先给 InstantiationAwareBeanPostProcessor 最后一次机会进行后置处理，主要是用来修改bean的属性值，如果返回false，那么方法将会返回，不进行后续操作（位置1）。
然后判断自动注入的类型，选择按照类型，名称还是其他的注入方式（默认为0）。
获取容器中所有的 InstantiationAwareBeanPostProcessor 执行他们实现的 postProcessProperties方法：
ConfigurationClassPostProcessor
用来增强bean工厂
CommonAnnotationBeanPostProcessor(处理@Resource)
处理JSR250相关的注入 @Resource
AutowiredAnnotationBeanPostProcessor(处理@Autowired，@Value)
主要用来处理 @Autowired 和 @Value 的注入
获取注入元数据 InjectionMetadata
InjectionMetadata.inject() 注入
遍历所有需要注入的属性，挨个注入
如果是@Value
AbstractBeanFactory.resoloveEmbeddedValue(value) 获取
从 this.embeddedValueResolver 中获取解析器解析并返回值
如果是@Autowired
最终会走到 DependencyDescriptor.resolveCandidate() 获取依赖的bean
本质上是调用 getBean 方法，不存在就先初始化依赖的bean。
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction 最终完成了Bean的创建之后，回到11.1的getSingleton(beanName, () -> {…})位置，使用addSingleton()方法将实例化好的单例添加到一级缓存中（同时从三级缓存中删除）。
protected void finishRefresh() { clearResourceCaches(); // 初始化和生命周期相关的处理器,如果没有则初始化一个DefaultLifecycleProcessor // LifecycleProcessor 定义了容器启动，关闭，刷新，停止的方法 initLifecycleProcessor(); // 调用 LifecycleProcessor 的刷新容器方法 getLifecycleProcessor().onRefresh(); // 发布容器刷新完成事件 publishEvent(new ContextRefreshedEvent(this)); if (!NativeDetector.inNativeImage()) { LiveBeansView.registerApplicationContext(this); }} 方法步骤：
初始化和生命周期相关的处理器,如果没有则初始化一个DefaultLifecycleProcessor
LifecycleProcessor 定义了容器启动，关闭，刷新，停止的方法，我们可以通过向容器中注册一个id为 lifecycleProcessor 的 LifecycleProcessor 处理器来实现自定义。
public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
调用处理器 LifecycleProcessor 的刷新容器方法，如果我们自定义了生命周期处理器，那么在这里将会被调用刷新方法 onRefresh()
发布容器刷新完成事件
ApplicationContext 继承了 ApplicationEventPublisher ，也是一个事件发布器。
观察者模式：如Spring的事件发布处理模型（这也是我们在开发中常用的，如MQ）
派发器（ApplicationEventMulticaster）派发事件，事件派发到具体的监听器Listener（相当于Observer），Listener做出处理。
单例模式：单例Bean实现都是通过单例模式
代理模式：AOP的实现用到了代理模式
模版方法模式：如Spring在初始化过程中为我们或出示例提供的一些模版方法
工厂方法模式：例如我们配置了一个FactoryBean的子类，使用工厂方法getObject()的方式获取对象。
转载地址：http://zkprn.baihongyu.com/