前言
本篇文章主要介绍 Spring 中 BeanFactory 的扩展 ApplicationContext，我们平时日常开发中也基本上是使用它，不会去直接使用 BeanFactory。
那么在 Spring 中 BeanFactory 和 ApplicationContext 有什么区别呢？
-
BeanFactory这个接口提供了高级配置的机制的管理对象，是一个基本的 IoC 的容器。 -
ApplicationContext是BeanFactory的一个子接口，提供了BeanFactory的全部功能，并且在此基础上还提供了：- 面向切面 (AOP)
- 配置元信息 (Configuration Metadata)
- 资源管理 (Resources)
- 事件 (Events)
- 国际化 (i18n)
- 注解 (Annotations)
- Environment 抽象 (Environment Abstraction)
真正的底层 IoC 容器是
BeanFactory的实现类，ApplicationContext中的getBean()其实都是委托给DefaultListableBeanFactory来实现。
正文
首先来看一段使用 ApplicationContext 的简单代码，然后我们逐渐往下分析。
XML配置文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.leisurexi.ioc.context" />
<bean id="user" class="com.leisurexi.ioc.context.domain.User">
<property name="id" value="1"/>
<property name="name" value="leisurexi"/>
</bean>
<bean id="city" class="com.leisurexi.ioc.context.domain.City">
<property name="id" value="1"/>
<property name="name" value="北京"/>
</bean>
</beans>
User 类定义如下：
public class User {
private Long id;
private String name;
@Autowired
private City city;
// 省略get和set方法
}
测试类，如下：
@Test
public void xmlApplicationContextTest() {
ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
User user = context.getBean("user", User.class);
System.out.println(user);
}
上面代码很简单，根据指定的文件加载 bean 定义，在调用 getBean() 获取 bean 实例。下面我们从上面代码开始一步一步分析 ApplicationContext 相比 BeanFactory 做了什么其它工作。
ClassPathXmlApplicationContext 构造函数
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
super(parent);
// 设置 XML 文件的路径
setConfigLocations(configLocations);
if (refresh) {
// 刷新上下文
refresh();
}
}
AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {
// 加锁
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 准备刷新的上下文环境，见下文详解
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 获取刷新后的beanFactory，一般都是创建一个DefaultListableBeanFactory，见下文详解
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 使用当前上下文环境准备beanFactory，见下文详解
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// beanFactory的后置处理，子类实现，这也算是beanFactory的扩展点
// AbstractRefreshableWebApplicationContext在这个方法内加入了request和session的作用域
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用所有BeanFactoryPostProcessors的实现类，见下文详解
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册BeanPostProcessors，见下文详解
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化消息资源，这里不做过多分析
initMessageSource();
// Initialize event multicaster for this context.
// 初始化事件传播器，这里不做过多分析
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 在特殊的上下文环境中初始化指定的bean，模板方法留给子类实现
onRefresh();
// Check for listener beans and register them.
// 注册监听器
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有非延迟加载的单例bean，见下文详解
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 完成上下文的刷新，调用生命周期处理器的onRefresh()并且发布上下文刷新完成事件
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.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
} finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
// 重置缓存，例如方法、字段等
resetCommonCaches();
}
}
}
AbstractApplicationContext#prepareRefresh
protected void prepareRefresh() {
// Switch to active.
// 记录开始时间
this.startupDate = System.currentTimeMillis();
// 上下文关闭标识设置为 false
this.closed.set(false);
// 上下文激活标识设置为 true
this.active.set(true);
// Initialize any placeholder property sources in the context environment.
// 初始化占位符属性资源，该方法是留给子类实现的，默认什么也不做
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
// 验证需要的属性文件是否都已经放入环境中
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners...
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
} else {
// Reset local application listeners to pre-refresh state.
// 在上下文刷新前重置监听器
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<>();
}
AbstractApplicationContext#obtainFreshBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 刷新 bean 工厂，见下文详解
refreshBeanFactory();
// 返回 bean 工厂，见下文详解
return getBeanFactory();
}
AbstractRefreshableApplicationContext#refreshBeanFactory
protected final void refreshBeanFactory() throws BeansException {
// 如果有beanFactory
if (hasBeanFactory()) {
// 销毁所有的单例bean
destroyBeans();
// 关闭beanFactory，也就是将beanFactory设置为null
closeBeanFactory();
}
try {
// 创建 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 指定序列化id
beanFactory.setSerializationId(getId());
// 定制beanFactory，设置相关属性
customizeBeanFactory(beanFactory);
// 加载beanDefinition
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
// 加锁，将beanFactory赋值给全局变量
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
上面代码中的 destroyBeans() 最终会调用 DefaultListableBeanFactory#destroySingletons() ，该方法在 Spring IoC createBean 方法详解 一文中已经介绍过，这里不再赘述。
loadBeanDefinitions() 方法最终会创建 XmlBeanDefinitionReader#loadBeanDefinitions() 去加载 bean 的定义元信息，该方法在 Spring XML Bean 定义的加载和注册 一文中已经介绍过，这里不再赘述；其中对 context:componment-scan 标签的解析在 Spring IoC component-scan 节点详解 一文中介绍过，这里也不再赘述。
AbstractRefreshableApplicationContext#getBeanFactory
public final ConfigurableListableBeanFactory getBeanFactory() {
// 加锁
synchronized (this.beanFactoryMonitor) {
// 如果beanFactory为空抛出异常
if (this.beanFactory == null) {
throw new IllegalStateException("BeanFactory not initialized or already closed - " + "call 'refresh' before accessing beans via the ApplicationContext");
}
// 返回beanFactory
return this.beanFactory;
}
}
AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
// 设置beanFactory的classLoader为当前context的classLoader
beanFactory.setBeanClassLoader(getClassLoader());
// 设置beanFactory的表达式语言处理器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 为beanFactory增加了一个的propertyEditor，这个主要是对bean的属性等设置管理的一个工具
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
// 添加bean扩展，主要是对ApplicationContext新增加的Aware接口进行调用
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(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 interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
// 注册解决依赖，也就是说我们可以通过依赖注入来注入以下四种类型的bean
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
// 将是ApplicationListener类型的bean在BeanPostProcessor的初始化后回调方法中加入到context的监听器列表中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 增加对AspectJ支持
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()));
}
// Register default environment beans.
// 如果beanFactory不存在名为environment的bean，添加默认的，该bean就和我们正常声明的单例bean一样
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 如果beanFactory不存在名为systemProperties的bean，添加默认的，该bean就和我们正常声明的单例bean一样
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 如果systemEnvironment不存在名为systemEnvironment的bean，添加默认的，该bean就和我们正常声明的单例bean一样
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
AbstractApplicationContext#invokeBeanFactoryPostProcessors
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 实例化并调用所有已注册的BeanFactoryPostProcessor
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()));
}
}
PostProcessorRegistryDelegate#invokeBeanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
// 判断beanFactory是否是BeanDefinitionRegistry类型，通常情况下这里的beanFactory是DefaultListableBeanFactory所以这里判断为true
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 保存实现了BeanFactoryPostProcessor bean的集合
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 保存实现了BeanDefinitionRegistryPostProcessor bean的集合
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 遍历beanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 找出是BeanDefinitionRegistryPostProcessor类型的并调用其postProcessBeanDefinitionRegistry()
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 将BeanDefinitionRegistryPostProcessor类型的添加进registryProcessors
registryProcessors.add(registryProcessor);
}
else {
// 将BeanFactoryPostProcessor类型的添加进regularPostProcessors
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<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 获取所有BeanDefinitionRegistryPostProcessor类型的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 遍历postProcessorNames
for (String ppName : postProcessorNames) {
// 如果实现了PriorityOrdered接口，
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 初始化此bean并添加进currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 将此beanName添加到已处理的记录中
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 将所有BeanDefinitionRegistryPostProcessor类型并且实现了PriorityOrdered接口的bean添加进registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
// 遍历调用currentRegistryProcessors中的所有BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空currentRegistryProcessors
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 和上面的差不多只是这次是实现了Ordered接口的，并且没有处理过的
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
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.
// 和上面的差不多只是这次是所有的实现了BeanDefinitionRegistryPostProcessors的bean，并且没有处理过的
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.
// 调用BeanFactoryPostProcessor的postProcessBeanFactory()
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类型的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 遍历postProcessorNames
for (String ppName : postProcessorNames) {
// 如果已经处理过，直接跳过；因为BeanDefinitionRegistryPostProcessor继承于BeanFactoryPostProcessor
// 所以postProcessorNames也包含BeanDefinitionRegistryPostProcessor类型的bean，这里会对BeanDefinitionRegistryPostProcessor类型的bean直接跳过
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 如果实现了PriorityOrdered接口，初始化该bean并添加进priorityOrderedPostProcessors
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 如果实现了Ordered接口，将beanName添加进orderedPostProcessorNames
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 正常的将beanName添加进nonOrderedPostProcessorNames
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 排序，然后调用BeanFactoryPostProcessors的postProcessBeanFactory()
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 和上面的一样这里是实现了Ordered接口的
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
// 和上面的一样这里是正常的BeanFactoryPostProcessors
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
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();
}
上面代码首先找出 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 类型的 bean，然后根据其实现的排序接口，来分别进行初始化以及调用其回调方法。可以把 PriorityOrdered 理解为 超级会员，Ordered 为 普通会员，都未实现的理解为 普通用户，优先级一个比一个高。
我们首先看一下 BeanFactoryPostProcessor 接口的定义：
@FunctionalInterface
public interface BeanFactoryPostProcessor {
/**
* 实例化bean之前调用，可以在此修改BeanDefinition
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
可以看出 BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。
接下里我们看一下 BeanDefinitionRegistryPostProcessor 接口的定义：
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
/**
* 实例化bean之前调用，可以在此注册bean或删除bean
*/
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
BeanDefinitionRegistryPostProcessor 比 BeanFactoryPostProcessor 具有更高的优先级，从上面解析的代码中就可以看出，主要用来在 BeanFactoryPostProcessor 之前注册其它 bean 的定义。
AbstractApplicationContext#registerBeanPostProcessors
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
//PostProcessorRegistrationDelegate.java
public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取所有实现了BeanPostProcessor的beanName，这里会获取到AutowiredAnnotationProcessor和CommonAnnotationProcessor后置处理器的beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 已经注册进beanFactory的数量 + 手动注册的BeanPostProcessorChecker + 实现了BeanPostProcessor还未注册的bean的数量
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 存储实现了PriorityOrdered接口的BeanPostProcessors
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 存储实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessors
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 存储实现了Ordered接口的BeanPostProcessors
List<String> orderedPostProcessorNames = new ArrayList<>();
// 存储正常的BeanPostProcessors
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 如果实现了BeanPostProcessor的bean实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 获取bean实例
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 添加进priorityOrderedPostProcessors
priorityOrderedPostProcessors.add(pp);
// 如果bean也实现了MergedBeanDefinitionPostProcessor，则添加进internalPostProcessors
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 如果实现了Ordered接口，添加进orderedPostProcessorNames
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 否则添加进nonOrderedPostProcessorNames
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 将实现了PriorityOrdered的BeanPostProcessors先排序再注册进beanFactory
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 将实现了Order的BeanPostProcessors先排序再注册进beanFactory
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
// 如果实现了MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 添加进internalPostProcessors
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 将正常的BeanPostProcessors注册进beanFactory
List<BeanPostProcessor> 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.
// 最后将实现MergedBeanDefinitionPostProcessor的BeanPostProcessors先排序再注册进beanFactory
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).
// 这里再次添加了ApplicationListenerDetector(之前在prepareBeanFactory()已经添加过)是为了获取代理
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
上面代码最后的部分会把实现了 MergedBeanDefinitionPostProcessor 会在最后重新注册一遍，大家可能会认为这不就重复注册了吗，其实不然，beanFactory#addBeanPostProcessor() 会首先删除老的，再重新添加新的。
根据上面代码大家也会发现，ApplicationContext 会帮我们自动注册实现了 BeanPostProcessors 的 bean，而使用 BeanFactory 就需要自己手动注册了。
AbstractApplicationContext#finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
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));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结所有的bean定义，也就是bean定义将不被修改或任何进一步的处理
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 初始化非延迟的单例bean，见下文详解
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// 获取合并的BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// bean不是抽象类 && bean是单例作用域 && bean不是延迟加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果bean的FactoryBean
if (isFactoryBean(beanName)) {
// 获取FactoryBean的实例，前面加了&符号
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext());
}
else {
// FactoryBean是否提前初始化
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
// 如果是提前初始化直接调用getBean()去初始化bean
if (isEagerInit) {
getBean(beanName);
}
}
}
// 直接调用getBean()去初始化bean
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
// 获取上面初始化后的单例bean
Object singletonInstance = getSingleton(beanName);
// 如果bean实现了SmartInitializingSingleton接口，调用afterSingletonsInstantiated()
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
上面代码中的 getMergedLocalBeanDefinition() 在[Spring IoC getBean 方法详解](https://leisurexi.github.io/category/2020/04/21/Spring IoC/Spring IoC getBean 方法详解.html)有解析过，这里不再赘述。这里介绍一下 SmartInitializingSingleton 接口，先看下该接口的定义：
public interface SmartInitializingSingleton {
/**
* 单例bean初始化完成之后调用
*/
void afterSingletonsInstantiated();
}
这个接口比较简单，就一个方法，并且只在 preInstantiateSingletons() 中调用了，也就是说你直接使用 BeanFactory 是不会调用该回调方法的。该接口回调方法在单例 bean 初始化完成之后调用后执行，属于 Spring Bean 生命周期的增强。
AbstractApplicationContext#finishRefresh
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清除资源缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 为此上下文初始化生命周期处理器，见下文详解
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 首先将刷新完毕事件传播到生命周期处理器，见下详解
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 发布上下文刷新完成的事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
AbstractApplicationContext#initLifecycleProcessor
protected void initLifecycleProcessor() {
// 如果当前beanFactory中含有名称为lifecycleProcessor的bean定义，初始化该bean并赋值给全局变量lifecycleProcessor
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
} else {
// beanFactory中没有名称为lifecycleProcessor的bean定义，创建一个DefaultLifecycleProcessor并当做单例bean注册进beanFactory
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
}
}
DefaultLifecycleProcessor#onRefresh
public void onRefresh() {
startBeans(true);
this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
// 获取所有实现了Lifecycle或者SmartLifecycle的单例bean
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
// 因为onRefresh()调用时该方法时，手动设置了autoStartupOnly为false，所以这里的bean必需是SmartLifecycle类型并且isAutoStartup()返回true
lifecycleBeans.forEach((beanName, bean) -> {
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 获取bean的阶段值（如果没有实现Phased接口，则值为0）
int phase = getPhase(bean);
// 拿到存放该阶段值的LifecycleGroup，如果为空则新建一个并把当前阶段值加入其中
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(beanName, bean);
}
});
// 如果phases不为空，根据阶段值从小到大排序，并调用重写Lifecycle接口的start()
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}
总结
本文主要介绍了 ApplicationContext 整个加载的流程，我们可以重新整理一下思路：
- 刷新前的准备，在这里会记录整个上下文启动的开始时间，将激活标识设置为
true，关闭标识设置为false。 - 创建一个新的
BeanFactory，这里大多数情况下都是DefaultListableBeanFactory。首先会检测之前有没有BeanFactory，有的话会先销毁再重新创建，然后会加载bean的定义元信息。 - 配置
BeanFactory，设置BeanFactory的classLoader、表达式语言处理器、添加了ApplicationContext新增加的Aware接口回调等。 - 调用
BeanFactory的后置处理器，这也是BeanFactory的扩展点；上文有分析过这里不再赘述。 - 注册容器内所有的
BeanPostProcessors，上文也分析过，不再赘述；值得注意的是如果单单使用BeanFactory的话是不会自动注册的。 - 初始化消息资源，这里没有过多分析，因为对我们整个流程几乎没什么影响。
- 初始化事件传播器。关于 Spring 的事件，我打算后面单独写一篇文章来介绍，这里就没有多说。
- 在特殊的上下文环境中初始化指定的bean，模板方法留给子类实现。
- 注册监听器，这也留着到 Spring 事件中一起介绍。
- 初始化所有非延迟加载的单例
bean，并且会回调实现了SmartInitializingSingleton接口的afterSingletonsInstantiated()，这个接口算是bean生命周期的增强。 - 完成上下文的刷新，调用生命周期处理器的
onRefresh()并且发布上下文刷新完成事件。
最后，我模仿 Spring 写了一个精简版，代码会持续更新。地址：https://github.com/leisurexi/tiny-spring。访问新博客地址，观看效果更佳 https://leisurexi.github.io/