前言：
Spring Bean 的生命周期是面试中 Spring 系列的一个高频问题，本篇我们将从源码方面来剖析 Spring Bean 的生命周期。
Spring 知识储备传送门：
深入理解 Spring IOC 底层实现机制（refresh 方法源码分析）
Spring 源码之 BeanDefinition 加载分析
Spring Bean 生命周期
我们知道 Spring 项目中，bean 都是交由 Spring IOC 容器来管理，由 IOC 容器帮我们帮我们管理 bean 对象的创建和销毁，在 Spring IOC 容器中，Spring Bean 的生命周期大致如下：
- 实例化：Spring 容器启动时，通过反射实例化 Bean。
- 属性赋值：实例化后，Spring 会对 Bean 的属性进行赋值。
- 执行前置处理方法：BeanPostProcessors 的 postProcessBeforeInitialization 方法。
- 执行初始化方法：执行一些 Bean 的初始化操作，对应 init-method。
- 执行后置处理方法：BeanPostProcessors 的 postProcessAfterInitialization 方法。
- 使用：Bean 初始化完毕，被应用程序使用。
- 销毁：关闭 IOC 容器的时候，Spring 会处理配置了销毁方法的 Bean。
Spring Bean 生命周期主脉络图
简单的画了一个 Spring Bean 生命周期的脉络图，帮助理解源码的同时加深我们对 Spring Bean 生命周期的理解。
Spring Bean 生命周期源码分析
我们知道非懒加载的 Bean 都是通过 AbstractApplicationContext#finishBeanFactoryInitialization 方法来创建的，下面我们以该方法为入口来分析一下 Spring Bean 的生命周期。
AbstractApplicationContext#finishBeanFactoryInitialization 方法源码分析
finishBeanFactoryInitialization 方法对 BeanFactory 做了一些设置，并继续调用了 DefaultListableBeanFactory#preInstantiateSingletons 方法进行非懒加载的 Bean 的实例化。
//beanFactory 创建完成 初始化单例bean
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//给 beanFactory 设置 ConversionService
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
//给 beanFactory 设置 值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
//获取所有的 LoadTimeWeaverAware 织入 Aspect AOP 相关
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
//初始化 LoadTimeWeaverAware bean
this.getBean(weaverAwareName);
}
//设置临时类加载器为 null
beanFactory.setTempClassLoader((ClassLoader)null);
//冻结BeanDefinition
beanFactory.freezeConfiguration();
//预实例化单例非懒加载 lazy-init 的 bean 调用了 DefaultListableBeanFactory#preInstantiateSingletons 方法
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons 方法源码分析
DefaultListableBeanFactory#preInstantiateSingletons 方法设置了 BeanFactory 的一些属性，调用了 DefaultListableBeanFactory#preInstantiateSingletons 方法
//beanFactory 创建完成 初始化单例bean
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//给 beanFactory 设置 ConversionService
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
//给 beanFactory 设置 值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
//获取所有的 LoadTimeWeaverAware 织入 Aspect AOP 相关
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
//初始化 LoadTimeWeaverAware bean
this.getBean(weaverAwareName);
}
//设置临时类加载器为 null
beanFactory.setTempClassLoader((ClassLoader)null);
//冻结BeanDefinition
beanFactory.freezeConfiguration();
//预实例化单例非懒加载 lazy-init 的 bean
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory#preInstantiateSingletons方法源码分析
DefaultListableBeanFactory#preInstantiateSingletons 循环遍历了 BeanDefinitions，核心是调用了 AbstractBeanFactory#getBean 方法。
//对懒加载的 bean 进行预实例化
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
//获取所有需要实例化的 beanDefinitionNames
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
//迭代器遍历
Iterator var2 = beanNames.iterator();
while(true) {
String beanName;
Object bean;
do {
//非工厂bean 逻辑
while(true) {
//定义 RootBeanDefinition
RootBeanDefinition bd;
do {
//beanDefinition 懒加载
do {
//非 单例bean
do {
//抽象bean(懒加载 非单例 抽象)
if (!var2.hasNext()) {
//获取迭代器
var2 = beanNames.iterator();
while(var2.hasNext()) {
//获取beanName
beanName = (String)var2.next();
// 获取beanName对应的bean实例
Object singletonInstance = this.getSingleton(beanName);
//singletonInstance 是否实现了 SmartInitializingSingleton 接口
if (singletonInstance instanceof SmartInitializingSingleton) {
//获取 StartupStep
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize").tag("beanName", beanName);
//类型转换
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
//触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
return;
}
//获取 beanName
beanName = (String)var2.next();
//合并 beanDefinitions
bd = this.getMergedLocalBeanDefinition(beanName);
} while(bd.isAbstract());
} while(!bd.isSingleton());
} while(bd.isLazyInit());
//beanName 是否实现了 FactoryBean 接口
if (this.isFactoryBean(beanName)) {
//根据&+beanName来获取具体的对象(do while 循环第一次会进来)
bean = this.getBean("&" + beanName);
break;
}
//没有实现FactoryBean 只是普通的bean 通过beanName获取bean实例 getBean 方法重点方法
this.getBean(beanName);
}
} while(!(bean instanceof FactoryBean));
FactoryBean<?> factory = (FactoryBean)bean;
//实现了 FactoryBean 接口的bean是否着急初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
SmartFactoryBean var10000 = (SmartFactoryBean)factory;
((SmartFactoryBean)factory).getClass();
isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
} else {
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
}
if (isEagerInit) {
//着急初始化 通过beanName获取bean实例 getBean 方法重点方法
this.getBean(beanName);
}
}
}
AbstractBeanFactory#getBean方法源码分析
AbstractBeanFactory#getBean 方法没有逻辑，接着调用了AbstractBeanFactory#doGetBean 方法。
public Object getBean(String name) throws BeansException {
//doGetBean 真正干活的方法 Spring 源码中 do 开头的才是真正干活的方法
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
AbstractBeanFactory#doGetBean 方法源码分析
看到 doGetBean 方法，熟悉 Spring 源码的都知道真正干活的方法出来了，doGetBean 方法会先判断 IOC 容器中是否有当前 Bean，没有的时候会对 BeanDefinitions 进行一些处理，比如合并 BeanDefinitions，检查 Bean 是否有循环依赖等，doGetBean 关键的点是接着调用了 AbstractAutowireCapableBeanFactory#createBean 方法。
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
//根据 name 获取beanName 如果是别名会将别名转换为规范的名称
String beanName = this.transformedBeanName(name);
//根据beanName 从容器中获取 bean 对象
Object sharedInstance = this.getSingleton(beanName);
Object bean;
//bean 不为空 直接从IOC 容器中获取 bean
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//对 bean 进行 BeanFactory 的相关操作(不是本次分析的重点)
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
//表示IOC 容器中没有当前单例 bean
if (this.isPrototypeCurrentlyInCreation(beanName)) {
//IOC 容器中正在创建原型bean 原型bean 中出现循环依赖直接抛出 bean 创建异常
throw new BeanCurrentlyInCreationException(beanName);
}
//获取父级 BeanFactory IOC 容器
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
//当前IOC容器的父容器存在 且当前容器中不存在当前beanName的 beanDefinition
//解析指定 Bean 名称的原始名称
String nameToLookup = this.originalBeanName(name);
//父IOC 容器是 AbstractBeanFactory
if (parentBeanFactory instanceof AbstractBeanFactory) {
//继续调用AbstractBeanFactory#doGetBean 方法查询单例bean
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
//委派父级IOC 容器根据指定名称和显式的参数查找
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
//委派父级IOC 容器根据指定名称和类型去查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
//委派父级IOC 容器根据指定名称去查找
return parentBeanFactory.getBean(nameToLookup);
}
//bean 是否需要做类型验证 一般不需要
if (!typeCheckOnly) {
//不需要做类型检查的时候 标记知道beanName 已经在创建中
this.markBeanAsCreated(beanName);
}
try {
//根据指定 beanName 合并 beanDefinition 主要是处理子类 bean 继承父类 bean 的公共属性问题
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//获取当前bean 的所有依赖bean 名称
String[] dependsOn = mbd.getDependsOn();
String[] var11;
//当前bean 依赖的bean 是否为空 不为空 优先创建依赖bean
if (dependsOn != null) {
var11 = dependsOn;
int var12 = dependsOn.length;
for(int var13 = 0; var13 < var12; ++var13) {
String dep = var11[var13];
//是否存在循环依赖 存在就报异常
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册各个bean 之间的关系 方便bean 销毁
this.registerDependentBean(dep, beanName);
try {
//创建依赖的bean
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var24) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
}
}
}
//是否是单例bean
if (mbd.isSingleton()) {
//创建bean 对象 并注册给所有依赖的bean
sharedInstance = this.getSingleton(beanName, () -> {
try {
//创建单例bean createBean 方法是重点方法
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
//创建失败显式地从单例缓存中删除实例
this.destroySingleton(beanName);
throw var5;
}
});
//获取指定的bean实例对象
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
//原型bean 每次都会创建一个新的对象
var11 = null;
Object prototypeInstance;
try {
//注册当前创建的原型bean 对象
this.beforePrototypeCreation(beanName);
//创建bean createBean 方法是重点方法
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
//异常回调 告诉容器 指定的bean 不再创建
this.afterPrototypeCreation(beanName);
}
//获取指定的bean实例对象
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
//既不是单例bean 也不是原型bean 根据bean 定义的作用域来创建bean
//获取bean的作用域(一般分为单例、原型、request、session、application、)
String scopeName = mbd.getScope();
//获取指定 bean 的作用域
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
//bean 作用域为空 抛出异常
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//匿名内部类 获取一个指定作用域的 bean
Object scopedInstance = scope.get(beanName, () -> {
//注册当前创建的bean 对象
this.beforePrototypeCreation(beanName);
Object var4;
try {
//创建bean createBean 方法是重点方法
var4 = this.createBean(beanName, mbd, args);
} finally {
//异常回调 告诉容器 指定的bean 不再创建
this.afterPrototypeCreation(beanName);
}
return var4;
});
//获取指定的bean实例对象
bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var23) {
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", var23);
}
}
} catch (BeansException var26) {
//bean 创建失败后的清理bean 工作
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
AbstractAutowireCapableBeanFactory#createBean 方法源码分析
AbstractAutowireCapableBeanFactory#createBean 方法主要是完成 Bean 的类加载器的加载，做一些 Bean 创建前的准备工作，createBean 方法的核心是调用了 AbstractAutowireCapableBeanFactory#doCreateBean 方法。
//创建 bean 对象
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//从 beanDefinition 中获取指定 benaName 的 class(如果 beanDefinition中没有class 则 resolveBeanClass方法会加载进去)
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//指定bean 的class 不为空 beanDefinition 的class 不是 Class 类型 beanDefinition对应的beanName 不为空
//重新定义一个 beanDefinition
mbdToUse = new RootBeanDefinition(mbd);
//把 resolvedClass 设置 beanDefinition 中
mbdToUse.setBeanClass(resolvedClass);
}
try {
//准备方法重写
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
//如果Bean配置了初始化前和初始化后的处理器 则试图返回一个需要创建Bean的代理对象
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
//真正创建bean 对象的方法 有 do 开头
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
AbstractAutowireCapableBeanFactory#doCreateBean 方法源码分析
doCreateBean 方法，又是 do 开头我们就知道这个方法是真正创建 Bean 的方法了，doCreateBean 方法包括 createBeanInstance Bean 对象的创建、populateBean 属性填充、initializeBean Bean 的初始化等操作，同时也有关于循环依赖的操作（本篇不展开讨论，后续会针对循环依赖进行博文分析）。
//真正创建Bean的方法
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//实例bean 的包装对象 beanWrapper 其实就是对bean 的包装
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果是单例bean 从 factoryBean 的缓存中移除当前bean (有可能在本Bean创建之前 就有其他Bean把当前Bean给创建出来了 比如依赖注入过程中)
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//根据beanName、bean的定义信息、args创建一个新的实例对象 根据指定bean使用对应的策略创建新的实例 工厂方法 构造函数自动注入 简单实例化 底层使用 cglib代理 和 反射生成实例对象
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
//获取 instanceWrapper 包装的 bean 实例
Object bean = instanceWrapper.getWrappedInstance();
//获取 instanceWrapper 包装的 class
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//加锁 保证线程安全
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//允许后置处理器修改合并后的 beanDefinition 将 工厂中的所有 MergedBeanDefinitionPostProcessors 应用到mbd 调用这些后处理器的 postProcessMergedBeanDefinition 方法
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
//标记该 beanDefinition 已经应用过 工厂中的所有 MergedBeanDefinitionPostProcessors
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");
}
//这里创建了一个匿名的ObjectFactory 工厂 可以用来获取对象
//addSingletonFactory 方法会将这个 匿名的ObjectFactory 工厂 放入到 singletonFactories 中 singletonFactories 是 Spring 的三级缓存
//为了避免循环依赖 尽早的持有对象的引用
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
//Bean对象的初始化 依赖注入在此触发
//这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean
Object exposedObject = bean;
try {
//bean 的属性填充 将bean 对象的实例封装 将Bean定义中配置的属性值赋值给实例对象
this.populateBean(beanName, mbd, instanceWrapper);
//bean 的初始化 包括应用工厂回调以及init方法和BeanPostProcessors
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) {
//需要暴露早期对象
//从一级 二级缓存中获取bean 对象
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
//bean 对象不为空 根据名称获取的已注册的Bean和正在实例化的Bean是同一个
if (exposedObject == bean) {
//当前实例化的Bean初始化完成
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
//当前Bean依赖其他Bean 并且当发生循环引用时不允许新创建实例对象
//获取当前bean 依赖的其他bean
String[] dependentBeans = this.getDependentBeans(beanName);
//实际依赖的bean
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
//遍历依赖的bean
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
//删除给定Bean名称的单例实例 但仅当它没有用于类型检查之外的其他目的时才删除
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
//没有删除的bean 加入到实际依赖的bean 中
actualDependentBeans.add(dependentBean);
}
}
//因为bean创建后其所依赖的bean一定是已经创建的 actualDependentBeans不为空则表示当前的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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//注册为一次性的bean 也就是处理Bean销毁前要执行的方法
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
AbstractAutowireCapableBeanFactory#populateBean 方法源码分析
populateBean 方法，非常熟悉的一个方法，作用就是将 Bean 属性设置到生成的实例对象上，包含了依赖注入的相关逻辑。
//将bean 属性设置到生成的实例对象上
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
//BeanWrapper 为空 且有依赖的属性 直接抛异常
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
} else {
//在设置属性之前 给任何InstantiationAwareBeanPostProcessors一个修改bean状态的机会
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var4 = this.getBeanPostProcessorCache().instantiationAware.iterator();
while(var4.hasNext()) {
InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var4.next();
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
//获取容器在解析Bean定义资源时为BeanDefiniton中设置的属性值
PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
//依赖注入的逻辑
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
//MutablePropertyValues是PropertyValues具体的实现类
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
if (resolvedAutowireMode == 1) {
//ByName
this.autowireByName(beanName, mbd, bw, newPvs);
}
if (resolvedAutowireMode == 2) {
//ByType
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 获取是否有实现InstantiationAwareBeanPostProcessor的方法 这里主要使用postProcessProperties方法。
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
// 获取是否需要进行依赖注入
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
// 属性为空 从beanDefinition中获取需要注入的信息
pvs = mbd.getPropertyValues();
}
PropertyValues pvsToUse;
for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {
//这里会调用AutowiredAnnotationBeanPostProcessor的 postProcessProperties()方法 会直接给对象中的属性赋值 真正的处理@Autowired @Resource @Value 等注解
//AutowiredAnnotationBeanPostProcessor内部并不会处理pvs。直接返回自己设置的PropertyValues对象（可以在实例化前设置）。
InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
//这里的含义是程序员自己已经给属性赋值了，就不需要Spring给他赋值。这里是程序员没有赋值，所以需要Spring进行赋值
pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//设置值
pvsToUse = bp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
}
}
//是否需要属性注入
if (needsDepCheck) {
if (filteredPds == null) {
//为空 则初始化
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
//检查依赖
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
if (pvs != null) {
//属性依赖注入
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
AbstractAutowireCapableBeanFactory#initializeBean 方法源码分析
initializeBean 方法，就对应了执行前置处理方法、初始化、执行后置处理方法，这每一步都在源码中有详细的说明。
//初始容器创建的Bean实例对象，为其添加BeanPostProcessor后置处理器
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
//JDK的安全机制验证权限
if (System.getSecurityManager() != null) {
//匿名内部类
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
//为Bean实例对象包装相关属性，如名称，类加载器，所属容器等信息
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//在初始化前 将BeanPostProcessors 应用到现有的bean 实例 调用他们的postProcessBeforeInitialization 方法
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//调用Bean实例对象初始化的方法 这个初始化方法是在Spring Bean定义配置
//文件中通过init-method属性指定的
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
//初始化后 将BeanPostProcessors 应用到现有的bean 实例 调用他们的postProcessAfterInitialization 方法
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
总结：本篇从源码层面简单分析了 Spring Bean 的生命周期，希望可以帮我们更好的理解 Spring，希望可以帮助到有需要的伙伴。
欢迎提出建议及对错误的地方指出纠正。
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
