Spring源码分析：IOC容器初始化(一)

原文发布于: http://blog.ztgreat.cn/article/57

前言

在前面 先分析了最底层的IOC容器BeanFactory,接着简单分析了高级形态的容器ApplicationContext，在ApplicationContext 中我们知道一个核心方法 refresh，这里面就是IOC容器的初始化流程，在前面并没有直接去分析它，只是简单的分析了BeanDefinition的载入,解析注册，有了这些基础后，再来完整的分析IOC容器的启动流程，并在适当的时候通过例子来说明。

需要以下基础内容:

Spring-BeanFactory源码分析(一)

Spring-统一资源加载策略

Spring-BeanFactory源码分析(二)

refresh 源码分析

在 AbstractApplicationContext 中以及将refresh整个流程定义出来了，我们再来看refresh 源码。

@Override
public void refresh() throws BeansException, IllegalStateException {
   // 同步操作
   synchronized (this.startupShutdownMonitor) {

      // 准备工作，记录下容器的启动时间、标记"已启动"状态
      prepareRefresh();

      // 这步在前面我们分析过，这步主要将配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
      // 但是此时 Bean 还没有初始化，只是配置信息都提取出来了，
      //这步中有 customizeBeanFactory 方法，具体在后面介绍
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
      //这个后面会具体介绍
      prepareBeanFactory(beanFactory);

      try {
         // 如果 Bean 实现了BeanFactoryPostProcessor接口，
         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。

         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
         postProcessBeanFactory(beanFactory);
         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
         registerBeanPostProcessors(beanFactory);

         // 初始化当前 ApplicationContext 的 MessageSource，不是重点，忽略
         initMessageSource();

         // 初始化当前 ApplicationContext 的事件广播器，忽略
         initApplicationEventMulticaster();

         // 模板方法
         // 具体的子类可以在这里做一些特殊操作
         onRefresh();

         // 注册事件监听器，监听器需要实现 ApplicationListener 接口，忽略
         registerListeners();

         // 初始化所有的 singleton beans
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);

         // 最后，广播事件，ApplicationContext 初始化完成
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         // 销毁已经初始化的 Bean
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);
         
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

准备工作-prepareRefresh

protected void prepareRefresh() {
   // 记录启动时间，
   this.startupDate = System.currentTimeMillis();
   // 设置容器状态
   this.closed.set(false);
   this.active.set(true);

   if (logger.isInfoEnabled()) {
      logger.info("Refreshing " + this);
   }

   // Initialize any placeholder property sources in the context environment
   initPropertySources();

   // 校验 xml 配置文件
   getEnvironment().validateRequiredProperties();

   this.earlyApplicationEvents = new LinkedHashSet();
}

这个比较简单，问题不大。

创建 Bean 容器，加载,注册 Bean

我们回到 refresh() 方法中的下一行 obtainFreshBeanFactory()。

注意，这个方法很重要，这里将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。

在Spring-BeanFactory源码分析(二) 中我们大致分析过了这个方法，这里就简单提一下就可以了，看一下在前面文章中没有提及的方法。

AbstractApplicationContext -> obtainFreshBeanFactory:

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
   refreshBeanFactory();

   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}

AbstractRefreshableApplicationContext->refreshBeanFactory:

@Override
protected final void refreshBeanFactory() throws BeansException {
  
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      // 初始化一个 DefaultListableBeanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // 用于 BeanFactory 的序列化
      beanFactory.setSerializationId(getId());

      // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
      customizeBeanFactory(beanFactory);

      // 加载 Bean 到 BeanFactory 中
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

这里主要看一下 customizeBeanFactory 方法：

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
  if (this.allowBeanDefinitionOverriding != null) {
    // 是否允许 Bean 定义覆盖
  	beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
  }
  if (this.allowCircularReferences != null) {
    // 是否允许 Bean 间的循环依赖
  	beanFactory.setAllowCircularReferences(this.allowCircularReferences);
  }
}

BeanDefinition 的覆盖问题就是在配置文件中定义 bean 时使用了相同的 id 或 name，默认情况下，allowBeanDefinitionOverriding 属性为 null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。

循环引用也很好理解：A 依赖 B，而 B 依赖 A。或 A 依赖 B，B 依赖 C，而 C 依赖 A。

默认情况下，Spring 允许循环依赖，当然如果你在 A 的构造方法中依赖 B，在 B 的构造方法中依赖 A 是不行的。

之后的源码中还会出现这两个属性，这里先知道就可以了。

prepareBeanFactory

之前我们说过，Spring 把我们在 xml 配置的 bean 都注册以后，会"手动"注册一些特殊的 bean。

这里简单介绍下 prepareBeanFactory (factory) 方法：

/**
 * Configure the factory's standard context characteristics,
 * such as the context's ClassLoader and post-processors.
 * @param beanFactory the BeanFactory to configure
 */
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // BeanFactory 需要加载类，因此需要类加载器，
   // 这里设置为加载当前 ApplicationContext 类的类加载器
   beanFactory.setBeanClassLoader(getClassLoader());

   // 设置 BeanExpressionResolver
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   //关于 属性编辑器
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

   // 添加一个 BeanPostProcessor，这个 processor 比较简单：
   // 实现了 Aware 接口的 beans 在初始化的时候，这个 processor 负责回调，
   // 这个我们很常用，如我们会为了获取 ApplicationContext 而 implement ApplicationContextAware
   // 注意：它不仅仅回调 ApplicationContextAware，
   // 还会负责回调 EnvironmentAware、ResourceLoaderAware 等，看下源码就清楚了
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

   // 下面几行的意思就是，如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，
   // Spring 会通过其他方式来处理这些依赖。
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

   /**
    * 下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，
    * 之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行
    * ApplicationContext 还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource
    * 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext
    */
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);

   // 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
   // 那么将其添加到 listener 列表中，可以理解成：注册 事件监听器
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

   // 这里涉及到特殊的 bean，loadTimeWeaver，忽略
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }

   /**
    * Spring它会帮我们默认注册一些有用的 bean，
    * 我们也可以选择覆盖
    */

   // 如果没有定义 "environment" 这个 bean，那么 Spring 会 "手动" 注册一个
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   // 如果没有定义 "systemProperties" 这个 bean，那么 Spring 会 "手动" 注册一个
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   // 如果没有定义 "systemEnvironment" 这个 bean，那么 Spring 会 "手动" 注册一个
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
}

不用每个地方都要看懂，我自己也只能看个大概，毕竟Spring还是很庞大的，主要了解我们平常最常用的就可以了，一些其它细节可以在大致掌握Spring 框架大概后再来进行模块化的研究。

postProcessBeanFactory

注册需要的BeanPostProcessor,

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

在AbstractApplicationContext 中是空方法（会加载一些默认的BeanPostProcessor），扩展部分交由具体的子类来实现。

invokeBeanFactoryPostProcessors

下面代码中我们需要注意getBeanFactoryPostProcessors()，它是获取的手动注册的BeanFactoryPostProcessor。

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		//忽略
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

下面开始我们的大头，看看这个invokeBeanFactoryPostProcessors中做的都是什么，这个方法很长，其实逻辑还是很简单的，最好自己对照着源码看。

public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set processedBeans = new HashSet<>();
        //判断该beanFactory 是否是 BeanDefinitionRegistry 类型
        //BeanDefinitionRegistry是可以注册Bean的
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List regularPostProcessors = new ArrayList<>();
			List registryProcessors = new ArrayList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					//调用postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List currentRegistryProcessors = new ArrayList<>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
			    //处理 PriorityOrdered 类型
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			//排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			//添加到要执行的集合中
			registryProcessors.addAll(currentRegistryProcessors);
			
			//调用 postProcessBeanDefinitionRegistry 方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
			    //处理 Ordered 类型
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		
		//获取 BeanFactoryPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List priorityOrderedPostProcessors = new ArrayList<>();
		List orderedPostProcessorNames = new ArrayList<>();
		List nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List orderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List nonOrderedPostProcessors = new ArrayList<>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
}

如果 beanFactory是BeanDefinitionRegistry的实例，这个BeanDefinitionRegistry是可以注册Bean的。然后处理我们手动注册的BeanFactoryPostProcessor，遍历每一个对象，验证是不是BeanDefinitionRegistryPostProcessor的实例。BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

如果是BeanDefinitionRegistryPostProcessor的实例，那么就强制类型转换后，执行BeanDefinitionRegistryPostProcessor的生命周期方法postProcessBeanDefinitionRegistry，并且将这个BeanFactoryPostProcessor放入到registryPostProcessors容器中.

如果不是BeanDefinitionRegistryPostProcessor的实例，那么直接放入到regularPostProcessors容器中。

processedBeans代表了一个已经处理过的Bean的容器，防止重复执行！
获取到的BeanDefinitionRegistryPostProcessor类型的Bean中，如果是PriorityOrdered类型的，那么会放入priorityOrderedPostProcessors容器中，然后排序，执行BeanDefinitionRegistryPostProcessor的生命周期方法postProcessBeanDefinitionRegistry。相同的方式再处理Ordered类型的，最后剩下的再单独处理。以上三种类型的postProcessBeanDefinitionRegistry处理完后，再执行BeanFactoryPostProcessor的生命周期方法postProcessBeanFactory。

如果 beanFactory不是BeanDefinitionRegistry的实例

直接执行BeanFactoryPostProcessor的生命周期方法postProcessBeanFactory，将手动添加的BeanFactoryPostProcessor处理掉。
上面处理的是BeanDefinitionRegistryPostProcessor，下面我们再处理BeanFactoryPostProcessor

String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

处理的方式同BeanDefinitionRegistryPostProcessor一致，先处理完PriorityOrdered，再处理Ordered，最后处理普通的，这里要注意的是，因为BeanDefinitionRegistryPostProcessor也是BeanFactoryPostProcessor，并且他之前已经处理过了，所以这个过程就不会在处理了。

举个例子

一个普通的BeanFactoryPostProcessor：

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public void postProcessBeanFactory(
            ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("this is MyBeanFactoryPostProcessor -> postProcessBeanFactory......");
    }

}

一个普通的BeanDefinitionRegistryPostProcessor，这个BeanDefinitionRegistryPostProcessor 在 postProcessBeanDefinitionRegistry 方法中注册上面的 MyBeanFactoryPostProcessor实例。

public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

        AbstractBeanDefinition beanDefinition = new RootBeanDefinition(MyBeanFactoryPostProcessor.class);

        registry.registerBeanDefinition("myBeanFactoryPostProcessor",beanDefinition);

    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        System.out.println("this is MyBeanDefinitionRegistryPostProcessor -> postProcessBeanFactory");
    }
}

最后在xml 中配置bean MyBeanDefinitionRegistryPostProcessor

执行结果：

this is MyBeanDefinitionRegistryPostProcessor -> postProcessBeanFactory
//...
this is MyBeanFactoryPostProcessor -> postProcessBeanFactory......

这样在BeanFactory 处理 BeanFactoryPostProcessor 时，会先处理BeanDefinitionRegistryPostProcessor ，这样就会将MyBeanFactoryPostProcessor 注册到BeanFactory中，这样MyBeanFactoryPostProcessor 就会在后续处理中得到执行。

这里只是简单的用了一个例子来描述 BeanFactoryPostProcessor 的处理逻辑，具体的过程可以通过代码debug来摸索。

registerBeanPostProcessors

在处理完 BeanFactoryPostProcessors 后会注册 BeanPostProcessors 注意这两个区别，前者主要是面向BeanFactory的，后者主要是面向Bean的，

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

这里也就不展开了，和处理 BeanFactoryPostProcessors 类似，只是这里注册BeanPostProcessors ，并没有执行其方法，具体的执行时机是在bean实例化的时候，到这里，BeanFactory中bean并没有实例化，这个我们后面会分析到。

onRefresh

这是一个模板方法，具体的还有待处理的流程交由子类来实现

finishBeanFactoryInitialization

这个方法很重要，这里会负责初始化所有的 singleton beans，鉴于篇幅不会在本文再来分析里面的逻辑了，文章太长看着也很累，这个就留到后面后面再来分析吧。

总结

我们来总结一下，到目前为止，可以说 BeanFactory 已经创建完成（内部使用的是DefaultListableBeanFactory），

实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到回调执行了。而且 Spring 已经"手动"注册了一些特殊的 Bean，如 ‘environment’、‘systemProperties’ 等。

实现了BeanPostProcessor 接口的Bean都已被注册（未执行）。

接下来就是处理国际化消息，事件，监听器了，不过目前不是我们的重点，这些就暂时忽略了。

剩下的就是初始化 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

参考

Spring IOC 容器源码分析

Spring 技术内幕