解析 Spring 启动流程与 Bean 生命周期:结合源码介绍 IOC 容器启动
本文详细解析了 Spring 启动流程与 Bean 生命周期,
前言
在 Spring 框架中,Bean 的生命周期是指从创建到销毁的整个过程。在这个过程中,Spring 提供了丰富的扩展点,允许开发者在不同阶段插入自定义逻辑。为了深入理解 Spring 的启动流程和 Bean 生命周期,本文将结合源码详细介绍 Spring IOC 容器的启动过程,并探讨 Bean 生命周期的各个阶段及其实现细节。
为了更好地学习源码,理解 Spring 的思想,可以看看一个开源项目:mini-spring。这是由字节跳动的一位大佬编写的开源项目,保留了 Spring 的核心代码,同时简化了一些不影响我们学习的核心逻辑。推荐用这套代码进行学习。
在本文中,我将通过 Spring 源码与 mini-spring 两个版本来介绍 Spring 的启动过程,以帮助大家更好地理解 Spring IOC 容器的加载与 Bean 的生命周期。
Spring 源码
为了清楚了解 Bean 的实例化是在哪发生的,以及前面做了哪些准备工作,先带大家了解下 Spring 的启动过程。Spring 容器启动流程主要包括两个过程:容器初始化和容器刷新。
常用的容器有如下两种:
- 基于 XML 配置 Bean (
ClassPathXmlApplicationContext) - 基于注解配置 Bean (
AnnotationConfigApplicationContext)
1、加载配置文件
首先,Spring 会根据配置文件(如 XML、Java 配置类)或注解(如 @Component、@Bean)来读取 Bean 的定义信息。
我这里以 ClassPathXmlApplicationContext 为例:

会解析当前配置的路径:

完成后开始执行 refresh() 方法,即 IOC 容器启动过程。
2、加载 IOC 容器
首先,我先总体说下 refresh() 主要干了什么事:
- 记录下容器的启动时间、标记“已启动”状态
- 创建容器DefaultListableBeanFactory,并加载beanDefinitions
- 对容器进行配置,比如注册类加载器ClassLoader和post-processors
- 调用 BeanFactoryPostProcessor 的 postProcessBeanFactory ,可对beanDefinition进行修改
- 注册 BeanPostProcessor 的实现类,可用于拦截bean的创建过程
- 国际化,事件广播器
- 初始化所有的 singleton beans(重点重点)
- 最后,广播事件,ApplicationContext 初始化完成
下面是 Spring 源码部分,我加上了中文注释:
java
@Override
public void refresh() throws BeansException, IllegalStateException {
// 加锁,防止在refresh的时候出现启动或销毁容器的操作。
synchronized (this.startupShutdownMonitor) {
// 准备工作,记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
prepareRefresh();
// 初始化 BeanFactory,先创建DefaultListableBeanFactory 实例,然后将配置信息解析成 beanDefinition,并封装成 beanName -> beanDefinition 的 ConcurrentHashMap 放在 BeanFactory 中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// BeanFactory 后置器处理
prepareBeanFactory(beanFactory);
try {
// 加载、注册 Bean,添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
postProcessBeanFactory(beanFactory);
// 在bean实例化之前,执行 BeanFactoryPostProcessor
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法,可修改beanDefinition
invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类,注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意,到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);
// 初始化当前 ApplicationContext 的 MessageSource,对不同语言的消息体进行国际化处理
initMessageSource();
// 初始化事件发布者
initApplicationEventMulticaster();
// 从方法名就可以知道,典型的模板方法(钩子方法),
// 具体的子类可以在这里初始化一些特殊的 Bean(在初始化 singleton beans 之前)
onRefresh();
// 注册事件监听器,检查监听Bean并且将这些Bean向容器注册,监听器需要实现 ApplicationListener 接口。
registerListeners();
// 重点!!! 注册类型转换器和提前实例化单例bean(lazy-init 的除外)
finishBeanFactoryInitialization(beanFactory);
// 最后,发布事件,ApplicationContext 初始化完成
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("上下文初始化期间遇到异常 - 取消刷新尝试: " + ex);
}
// 销毁已经创建的 bean,避免有些 bean 会一直占用资源
destroyBeans();
// 重置“active”标志
cancelRefresh(ex);
// 将异常传播给调用者
throw ex;
}
finally {
// 重置 Spring 核心中的常用缓存,因为我们可能不再需要单例 Bean 的元数据了
resetCommonCaches();
}
}
}
以上是 Spring IOC 容器启动流程的核心源码部分。下面我先简单结合源码介绍下 Bean 的生命周期。
3、Bean 的生命周期
在 Spring IOC 容器中,Bean 的生命周期大致如下:
- 实例化:当启动 Spring 应用时,IOC 容器会为在配置文件中声明的每个
<bean>创建一个实例。 - 属性赋值:实例化后,Spring 会通过反射机制给 Bean 的属性赋值。
- 调用初始化方法:如果 Bean 配置了初始化方法,Spring 会调用它。初始化方法是在 Bean 创建并赋值之后调用,可以在这个方法里写一些业务处理代码或做一些初始化工作。
- Bean 运行期:此时,Bean 已经准备好被程序使用,它已经被初始化并赋值完成。
- 应用程序关闭:当关闭 IOC 容器时,Spring 会处理配置了销毁方法的 Bean。
- 调用销毁方法:如果 Bean 配置了销毁方法,Spring 会在所有 Bean 都已使用完毕且 IOC 容器关闭之前调用它。可以在销毁方法里做一些资源释放的工作,比如关闭连接、清理缓存等。
下图展示了 Spring Bean 的生命周期:

3.1 finishBeanFactoryInitialization
java
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));
}
// 如果没有注册值解析器,则注册一个默认的嵌入值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 提前初始化 LoadTimeWeaverAware beans
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
// 冻结所有的 bean 定义,表示已注册的 bean 定义不会被修改或后置处理
beanFactory.freezeConfiguration();
// 实例化所有剩余的(非延迟初始化)单例 bean
beanFactory.preInstantiateSingletons();
}
在这个方法中,Spring 完成了以下几项工作:
- 设置类型转换器
- 注册一个默认的嵌入值解析器,用于解析注解中的属性值
- 提前初始化
LoadTimeWeaverAwarebeans - 停止使用临时类加载器进行类型匹配
- 冻结所有的 bean 定义,以防止后续修改
- 实例化所有非延迟初始化的单例 bean(重点!)。
通过这些步骤,Spring IOC 容器完成了对 Bean 的初始化工作,并准备好 Bean 供应用程序使用。
3.2 preInstantiateSingletons
该方法准备实例化并初始化所有非延迟加载的 Bean 的源码部分:
java
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
// 获取当前 BeanFactory 中所有的 Bean 定义名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
Iterator<String> iterator = beanNames.iterator();
// 遍历所有 Bean 定义
while (iterator.hasNext()) {
String beanName = iterator.next();
RootBeanDefinition bd = this.getMergedLocalBeanDefinition(beanName);
// 忽略抽象 Bean 定义
if (bd.isAbstract()) {
continue;
}
// 忽略非单例和懒加载的 Bean
if (!bd.isSingleton() || bd.isLazyInit()) {
continue;
}
// 如果是 FactoryBean,需要特别处理
if (this.isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) this.getBean("&" + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () -> ((SmartFactoryBean<?>) factory).isEagerInit(), this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit();
}
// 如果 FactoryBean 需要急切初始化
if (isEagerInit) {
this.getBean(beanName);
}
} else {
// 非 FactoryBean,直接实例化
this.getBean(beanName);
}
}
// 再次遍历所有 Bean,检查是否实现了 SmartInitializingSingleton 接口
iterator = beanNames.iterator();
while (iterator.hasNext()) {
String beanName = iterator.next();
Object singletonInstance = this.getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
3.3 doGetBean
该方法负责获取 Bean 实例,这个过程可能会从单例缓存中获取实例或者创建新的实例。
java
/**
* 返回指定 bean 的实例,该实例可以是共享的也可以是独立的。
* @param name 要检索的 bean 的名称
* @param requiredType 要检索的 bean 的所需类型
* @param args 使用显式参数创建 bean 实例时使用的参数(仅在创建新实例时适用,而不是检索现有实例时)
* @param typeCheckOnly 是否仅为类型检查获取实例,而不是实际使用
* @return bean 的实例
* @throws BeansException 如果无法创建 bean
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 调用getSingleton判断容器中有没有实例或者该bean有没有再创建的过程中
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
} else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
// 如果当前正在创建这个原型 bean 实例,则失败:
// 我们可能在一个循环引用中。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查这个工厂中是否存在 bean 定义。
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 未找到 -> 检查父工厂。
String nameToLookup = originalBeanName(name);
if (args != null) {
// 使用显式参数委托给父工厂。
return (T) parentBeanFactory.getBean(nameToLookup, args);
} else {
// 没有参数 -> 委托给标准 getBean 方法。
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 确保当前 bean 依赖的 bean 已初始化。
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
getBean(dependsOnBean);
}
}
// 创建 bean 实例。
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
// 明确地从单例缓存中移除实例:它可能已被创建过程急切地放入,以允许解决循环引用。
// 同时移除任何已接收该 bean 临时引用的 bean。
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
// 如果是原型 -> 创建新实例。
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
final 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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
} finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
} catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查所需类型是否与实际 bean 实例的类型匹配。
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
} catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
3.4 getSingleton
获取缓存中的 Bean 实例
该方法尝试从单例缓存中获取 Bean 实例的源码,这里面有三级缓存,这里先简单过一下。
java
// 一级缓存,存放完全实例化的 Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 三级缓存,存放提前暴露的 bean 工厂,用于解决循环依赖
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 二级缓存,用于存放早期暴露的不完全实例化的 Bean
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 缓存正在创建的单例 Bean 的名称
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存中获取完全实例化的 Bean
Object singletonObject = this.singletonObjects.get(beanName);
// 如果一级缓存中没有找到,并且该 Bean 被标记正在创建中
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
synchronized(this.singletonObjects) {
// 尝试从二级缓存中获取早期暴露的不完全实例化的 Bean
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果二级缓存中没有找到,并且允许早期引用
if (singletonObject == null && allowEarlyReference) {
// 从三级缓存中获取对应的 ObjectFactory
ObjectFactory<?> singletonFactory = (ObjectFactory<?>) this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 通过 ObjectFactory 创建 Bean 实例
singletonObject = singletonFactory.getObject();
// 将创建的实例放入二级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
// 从三级缓存中移除已创建的 Bean 工厂
this.singletonFactories.remove(beanName);
}
}
}
}
// 返回创建的 Bean 实例,如果为空对象则返回 null
return singletonObject != NULL_OBJECT ? singletonObject : null;
}
创建 bean 实例
如果缓冲中获取不到A,也不在创建过程中,则调用该方法创建并获取 bean
java
/**
* 返回给定名称的单例 bean 实例,如果当前还没有,则创建并注册一个新的实例。
* @param beanName bean 的名称
* @param singletonFactory 如果没有找到实例,则创建一个新实例的工厂
* @return 单例 bean 实例
*/
protected Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
// 首先从缓存中获取单例对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 如果没有获取到,说明该 bean 还没有被创建过
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 标记为创建中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
// 从 ObjectFactory 中创建对象
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
3.5 createBean
该方法会在 Bean 实例化之前做一些处理,之后对 Bean 进行实例化。
java
/**
* 该类的核心方法:创建一个 bean 实例,填充 bean 实例的属性,应用后处理器等。
* @param beanName 要检索的 bean 的名称
* @param mbd 用于创建 bean 的合并 bean 定义
* @param args 用于构造函数或工厂方法调用的显式参数
* @return bean 的一个新实例
* @throws BeanCreationException 如果无法创建 bean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 确保此时已经解析了 bean 类,如果是动态解析的类,克隆 bean 定义
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 准备方法覆盖
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 允许 BeanPostProcessors 在目标 bean 实例化之前返回代理
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
} catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
// 实际创建 bean 实例
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
3.6 doCreateBean
该方法负责创建一个 bean 实例并进行初始化过程。这个方法是 Spring 中的一个核心方法,用于处理 bean 的创建和初始化的具体步骤。其主要任务包括实例化 bean、填充 bean 属性以及处理各种初始化回调,可以参考下流程图:

java
/**
* 实际创建指定的 bean。在此时已经进行了预创建处理,例如检查 postProcessBeforeInstantiation 回调。
* @param beanName bean 的名称
* @param mbd bean 的合并 bean 定义
* @param args 用于构造函数或工厂方法调用的显式参数
* @return bean 的一个新实例
* @throws BeanCreationException 如果无法创建 bean
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
// 实例化 bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 通过反射或者代理创建bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// 允许后处理器修改合并后的 bean 定义
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// 预先缓存单例,以便在生命周期接口(如 BeanFactoryAware)触发时解析循环引用
// 当前 bean 是否需要提前曝光 = isSingleton 是否单例 && allowCircularReferences 允许循环依赖 && isSingletonCurrentlyInCreation 当前 bean 正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 这里主要是调用该方法,往三级缓存中放入一个当前 bean 的 ObjectFactory
// 以便之后其他 bean 对当前 bean 有依赖时,可以通过里边的 getEarlyBeanReference 获取到当前 bean 实例的引用
// 从而解决循环依赖
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// 初始化 bean 实例
Object exposedObject = bean;
try {
// 填充 bean 的属性,将各个属性值注入,其中可能存在依赖于其他bean的属性,会递归初始化
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 填充属性后对 bean 进一步初始化
// 如注入 Aware相关对象,调用后置处理器
// 调用 后置处理器 BeanPostProcessor 里面的postProcessBeforeInitialization方法
// 调用 initialzingBean,调用实现的 afterPropertiesSet()
// 调用 init-mothod,调用相应的init方法
// 调用 后置处理器 BeanPostProcessor 里面的调用实现的postProcessAfterInitialization方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
} catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 处理早期单例暴露的情况
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
// earlySingletonReference 只有在检测到有循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
// 如果exposedObject 没有在初始化方法中被改变,也就是没有被增强
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 检查依赖
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// 到这一步的话,正常 bean 是已经实例化和初始化完成了,也就是它所依赖的其他 bean 已经创建完成了
// 如果还有依赖的 bean没有创建,那双方相当于构成了循环依赖,从而导致没有创建完成,则抛异常
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 注册可销毁的 bean
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
3.7 populateBean
该方法主要会给实例化后的 bean 填充属性,在这之前会将 bean 所有需注入的属性进行获取。
java
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// 对于 null 实例,跳过属性填充阶段。
return;
}
}
// 让任何 InstantiationAwareBeanPostProcessors 有机会在设置属性之前修改 bean 的状态。
// 例如,这可以用来支持字段注入的风格。
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 如果后处理器发出停止填充命令则终止后续的执行
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 如果适用,基于按名称自动装配添加属性值。
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
// 根据名称自动注入
autowireByName(beanName, mbd, bw, newPvs);
}
// 如果适用,基于按类型自动装配添加属性值。
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
// 根据类型自动注入
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 后处理器是否已经初始化
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 是否需要依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 对所有需要依赖检查的属性进行后处理
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
// 依赖检查,对应depends-on属性,3.0已经弃用此属性
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
// 将属性应用到bean中
// 将所有ProtertyValues中的属性填充至BeanWrapper中
applyPropertyValues(beanName, mbd, bw, pvs);
}
3.8 applyPropertyValues
到这一步时,我们已经完成了对所有注入属性的获取,但是获取的属性是以 PropertyValues 形式存在的,还并没有应用到已经实例化的bean中,故由此方法处理。
java
/**
* 应用给定的属性值,解析对该 bean 工厂中其他 bean 的任何运行时引用。必须使用深拷贝,因此我们不会永久修改此属性。
*
* @param beanName 传递 bean 名称以获得更好的异常信息
* @param mbd 合并的 bean 定义
* @param bw 包装目标对象的 BeanWrapper
* @param pvs 新的属性值
*/
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
if (pvs == null || pvs.isEmpty()) {
return;
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
if (System.getSecurityManager() != null) {
if (bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
}
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
// 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中
if (mpvs.isConverted()) {
// 快捷方式:使用预转换的值。
try {
bw.setPropertyValues(mpvs);
return;
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
} else {
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
// 获取对应的解析器
BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// 创建深拷贝,解析值的任何引用。
List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
boolean resolveNecessary = false;
// 遍历属性,将属性转换为对应类的对应属性的类型
for (PropertyValue pv : original) {
if (pv.isConverted()) {
deepCopy.add(pv);
} else {
String propertyName = pv.getName();
Object originalValue = pv.getValue();
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// 可能在合并的 bean 定义中存储转换后的值,以避免每个创建的 bean 实例的重新转换。
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
} else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
} else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// 设置我们(可能已处理的)深拷贝。
try {
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
} catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
3.9 initializeBean
到这一步是,bean 已经完成了实例化 createBeanInstance(),并填充了属性 populateBean()
java
/**
* 初始化给定的 bean 实例,应用工厂回调、初始化方法和 bean 后置处理器。
* <p>该方法在 {@link #createBean} 方法中调用以初始化传统定义的 bean,
* 并在 {@link #initializeBean} 方法中调用以初始化现有的 bean 实例。
* @param beanName 工厂中的 bean 名称(用于调试目的)
* @param bean 需要初始化的新 bean 实例
* @param mbd 创建该 bean 的 bean 定义(如果给定现有的 bean 实例,也可以为 {@code null})
* @return 初始化后的 bean 实例(可能被包装过)
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
// 对特殊的 bean 进行处理:如实现了 Aware、BeanClassLoaderAware、BeanFactoryAware 的处理
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
// 激活 Aware 方法
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 调用 bean 初始化前的 BeanPostProcessor 方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 激活自定义的init的方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 调用 bean 初始化后的 BeanPostProcessor 方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
4、实例演示
下面简单演示下 Spring Bean 的实例化、初始化、销毁过程。
4.1、准备项目
这边我就直接使用 Spring Boot 项目来演示。
4.2、编写 Bean 类
java
package com.salmon.demo;
public class MyBean {
public MyBean() {
System.out.println("MyBean 实例化");
}
public void init() {
System.out.println("MyBean 初始化");
}
public void destroy() {
System.out.println("MyBean 销毁");
}
}
4.3、编写配置类
java
package com.salmon.demo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MyBeanConfig {
@Bean(initMethod = "init", destroyMethod = "destroy")
public MyBean myBean() {
return new MyBean();
}
}
4.4、编写主类
java
package com.salmon.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
4.5、运行项目
运行项目后,可以看到控制台输出如下信息:

mini-spring 源码
在上边,如果觉得跟踪源码比较复杂,可以看看这个精简版的 Spring,下边我将贴上这个精简版的 Spring 核心启动过程,和加载 IOC 容器、Bean 的生命周期。
1、加载配置文件
这里我还是以读取 xml 文件来加载 bean 定义信息为例

2、加载 IOC 容器
接下来是加载 IOC 容器的核心过程。

2.1 refreshBeanFactory
主要是创建 DefaultListableBeanFactory,往 DefaultListableBeanFactory 载入 BeanDefinition

从配置文件中加载 bean 的定义信息

2.2 getBeanFactory
将刚刚创建的 DefaultListableBeanFactory 返回,里面已经封装着我们的 bean 定义信息了

2.3 addBeanPostProcessor
添加 ApplicationContextAwareProcessor,让继承自 ApplicationContextAware的 bean 能感知 bean,Spring 会在这些 bean 初始化时调用它们的 setApplicationContext 方法,从而注入 ApplicationContext 实例。

2.4 invokeBeanFactoryPostProcessors
在 bean 实例化之前,执行 BeanFactoryPostProcessor,BeanFactoryPostProcessor 是 Spring 提供的一种扩展点,它允许在 bean 实例化之前对 BeanFactory 进行修改,这个方法会遍历所有的 BeanFactoryPostProcessor 并执行它们的 postProcessBeanFactory 方法

2.5 registerBeanPostProcessors
将所有的 BeanPostProcessor 提前注册到 BeanFactory 中,在其他 bean 实例化之前。BeanPostProcessor 是 Spring 的另一种扩展点,允许在 bean 的初始化前后进行自定义操作。比如,AutowiredAnnotationBeanPostProcessor 会处理 @Autowired 注解。这个方法会将所有实现了 BeanPostProcessor 接口的 bean 提前注册到 BeanFactory 中,以确保它们在其他 bean 初始化过程中能够被正确应用。

BeanPostProcessor 接口如下:

2.6 initApplicationEventMulticaster
初始化事件发布者 ApplicationEventMulticaster。ApplicationEventMulticaster 是 Spring 的事件发布机制的核心组件,它负责将事件发布给所有注册的监听器。

在 AbstractApplicationContext 中维护着一个单例的全局的事件发布者。

2.7 registerListeners
注册所有的事件监听器。这个方法会查找并注册所有实现了 ApplicationListener 接口的 bean。注册后,这些监听器将能够接收到由 ApplicationEventMulticaster 发布的事件,并对事件做出响应。

2.8 finishBeanFactoryInitialization
这是 IOC 容器的核心的方法,也是 Bean 生命周期的过程。该方法会注册类型转换器和提前实例化所有的单例 bean(不处理懒加载)

2.9 finishRefresh
发布容器刷新完成事件

让全局的事件发布者发布事件,通知它们 IOC 容器加载完成啦

让所有事件监听器收到该事件并处理

到这里,我就介绍完 IOC 容器的加载过程了,接下来,我会讲一下 bean 的生命周期,也就是在准备实例化和初始化 bean 的过程。
3、Bean 的生命周期
bean 的生命周期如下:

3.1 preInstantiateSingletons
准备实例化与初始化所有的单例且非懒加载的 bean

3.2 getBean
创建实例化的 bean 并初始化

其中会先从三级缓存中去获取实例化的 bean,为了解决循环依赖

执行完 createBean 后,会判断 Bean 是否实现了 FactoryBean 接口,如果实现了,则会调用 getObject ,如果是单例,则会放入缓存中,之后从缓存获取

3.3 createBean
开始创建 bean,在这之前,会先判断是否该 bean 需要代理对象,如果需要,则直接返回代理对象

执行 bean 实例化前和实例化后处理的方法,返回该 bean 的代理对象,比如生成 aop 的代理对象

3.4 doCreateBean
该方法会进行 bean 的实例化,属性填充、bean 的初始化


3.4.1 createBeanInstance
首先先创建 bean 的实例,此时的 bean 实例是不完整的

会根据当前 bean 的情况来根据反射或者 cglib 来创建 bean 实例

通过反射创建实例

通过 cglib 创建实例

3.4.2 addSingletonFactory
为了解决循环依赖问题,提前暴露 bean 对象,放入三级缓存中



3.4.3 applyBeanPostProcessorsAfterInstantiation
bean 实例化后的一些处理

3.4.4 applyBeanPostProcessorsBeforeApplyingPropertyValues
在设置 bean 属性之前,允许 BeanPostProcessor 修改属性值

将 BeanPostProcessor 的属性值添加到 BeanDefinition 中所维护的 PropertyValues

3.4.5 applyPropertyValues
为 bean 填充属性,并在此注入属性或者依赖的 bean 对象,最后通过反射设置属性值

3.4.6 initializeBean
执行 bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法

3.4.7 registerDisposableBeanIfNecessary
注册有销毁方法的 bean

3.4.8 addSingleton
将实例化后的单例 bean 添加到一级缓存中,同时删除二三级缓存


至此,mini-spring 的 Spring 启动流程的核心代码部分就讲解完了。
Spring 如何解决循环依赖
为了理解 Spring 如何解决循环依赖的问题,我们可以通过一段具体的代码流程来详细解析其中的过程。假设我们有两个类 A 和 B,它们互相依赖:
java
@Component
public class A {
@Autowired
private B b;
}
@Component
public class B {
@Autowired
private A a;
}
当 Spring 尝试实例化这两个类时,会触发循环依赖的处理机制。我们将通过源码深入分析这个过程:
步骤 1:实例化 A
Spring 首先尝试实例化 A,调用 doGetBean 方法:
java
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
Object sharedInstance = this.getSingleton(beanName);
// 省略部分代码
}
调用 getSingleton 方法判断容器中是否已有 A:
java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
在 getSingleton 方法中,首先检查 singletonObjects 中是否已有 A,如果没有,再检查是否在创建中(通过 singletonsCurrentlyInCreation 集合),然后调用 beforeSingletonCreation(beanName) 将 A 标记为创建中。
步骤 2:实例化 B
在 createBean 方法中,当创建 A 时,需要填充其依赖的属性,这时会调用 populateBean 方法:
java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
this.populateBean(beanName, mbd, instanceWrapper);
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
在 populateBean 方法中,Spring 发现 A 需要依赖 B,于是再次调用 getBean(B) 方法。
步骤 3:再次调用 getBean 方法实例化 B
同样的,调用 doGetBean 方法,然后进入 getSingleton 方法:
java
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
此时 B 还未被创建,于是 Spring 开始创建 B,但在创建 B 时发现 B 依赖 A,于是再调用 getBean(A)。
步骤 4:处理循环依赖
这时 A 已经在创建过程中,因此进入 isSingletonCurrentlyInCreation(beanName) 判断:
java
protected boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
发现 A 已经在创建过程中,于是从 singletonFactories 中获取 A 的工厂对象,调用 getEarlyBeanReference:
java
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
这样,Spring 从 singletonFactories 中获取到 A 的半成品对象,并将其放入 earlySingletonObjects 中,从而解决了循环依赖问题。
三个缓存的作用
- 一级缓存(singletonObjects):用于存储完整的单例对象。
- 二级缓存(earlySingletonObjects):用于存储对象的早期引用,防止重复创建。
- 三级缓存(singletonFactories):用于存储对象工厂,解决循环依赖时生成代理对象。
通过这三个缓存,Spring 能够有效地解决循环依赖问题,确保对象在创建过程中能够正确注入依赖并最终形成完整的 Bean 实例。(依赖的 Bean 必须是单例,依赖注入的方式,必须不全是构造器注入,且 beanName 字母在前的不能是构造器注入 )
结语
通过这次分析两种源码的过程中,无论是原版的 Spring 还是 mini-spring,都可以发现 Spring 的启动流程和 Bean 的生命周期是很复杂的,不过相信大家通过阅读简化版的 Spring,也能有不错的收货吧。