1.前言
在前面步骤中，Spring完成了ApplicationContext容器的创建、BeanFactory的创建、BeanDefintion的创建，为Bean的创建做好了前置准备工作，本文将针对Bean的生命周期结合Spring源码做分析。本文基于基于Spring5.3.37版本进行分析，ApplicationContext容器的创建、BeanFactory的创建可查看《Spring源码之Spring容器启动流程》，BeanDefinition的创建可查看《Spring源码之BeanDefinition扫描创建注册流程》。
对于普通的Java对象而言，当使用new 构造方法创建对象，对象即可使用，当不再使用时，由JVM自动进行垃圾回收。而Spring中的Bean，与我们主动调用new创建出来的对象没有区别，只不过创建过程由用户交给了IOC容器，并且Bean的管理也由IOC容器负责，当我们需要获取对应对象时，可以通过IOC容器进行获取。
本文分析的Spring的Bean生命周期针对的singleton类型的Bean，而不是prototype类型的Bean，因为prototype类型的Bean在通过IOC容器创建完成并交给使用者，不会进行生命周期的管理。
2.Bean的生命周期
Bean的生命周期可以概括为以下四个阶段，如图所示：
在这四个阶段中，Spring预埋了很多扩展点，均是通过回调BeanPostProcessor接口实现类的方法实现的，下图为Spring基于BeanPostProcessor在各阶段提供的重要扩展点示意图：
接下来将结合源码进行各阶段分析。
Spring容器中非懒加载的单例Bean均是在容器启动阶段创建的，对应入口为AbstractApplicationContext#finishBeanFactoryInitialization()方法，该方法内部调用了DefaultListableBeanFactory#preInstantiateSingletons()方法完成了创建工作。
DefaultListableBeanFactory#preInstantiateSingletons()
该方法内部主要做了两件事情：
1.调用父类的AbstractBeanFactory#getBean()方法获取（不存在则创建）Bean；
此步骤通过调用AbstractBeanFactory#doGetBean()方法，完成了Bean的获取（创建）。
内部涉及到FactoryBean的创建与普通Bean的创建，FactoryBean的创建比普通Bean在Bean生成后多了一步getObjectForBeanInstance()方法调用，该方法主要执行实现自FactoryBean的getObject()用于获取自定义的Bean对象，其余步骤均一样。因此本次主要分析普通Bean的创建。
2.针对实现了SmartInitializingSingleton接口的Bean，执行实现自该接口的afterSingletonsInstantiated()方法。
此步骤主要用于所有Bean创建完成后的一些全局性操作，如CacheAspectSupport#afterSingletonsInstantiated()的设置CacheManager，ContextLifecycleScheduledTaskRegistrar#afterSingletonsInstantiated()的添加和调度定时任务等。
AbstractBeanFactory#doGetBean()
该方法的核心步骤为：
1.转换Bean的名称。主要针对两种情况：
①FactoryBean,，若要取得FactoryBean对应的原始Bean，则需要在Bean的名称前添加&符号；
②Bean取别名的情况，对于别名的情况通过SimpleAliasRegistry的aliasMap属性找得原始Bean名称。
2.当前BeanFactory未找到指定BeanName的BeanDefintiion情况下，则从父BeanFactory中继续查找及调用getBean()方法；
3.合并BeanDefinition，在之前的xml配置Bean的方式中，可以通过指定parent的方式继承父Bean的相关属性；
4.创建依赖的Bean。如果类上存在@DependsOn注解，说明依赖其他Bean，需要先把依赖的Bean创建出来，再回来创建当前Bean；
5.创建Bean
根据Scope判断要创建的singleton还是prototype，或者是他的Bean。核心方法为AbstractBeanFactory#createBean()，对应的实现类是AbstractAutowireCapableBeanFactory。
6.Bean适配。如果Bean实例与要求的类型不一样，则调用TypeConverter#convertIfNecessary()方法进行转换，一样则直接返回。
源码如下：
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 转换Bean的名称，主要针对两种情况：
// 1.FactoryBean,，若要取得FactoryBean对应的原始Bean，则需要在Bean的名称前添加&符号
// 2.Bean取别名的情况，对于别名的情况通过SimpleAliasRegistry的aliasMap属性找得原始Bean名称
String beanName = transformedBeanName(name);
Object beanInstance;
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 省略日志代码...
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 如果当前BeanFactory未找到指定BeanName的BeanDefintiion，则从父BeanFactory中继续查找及调用getBean()方法
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
// 避免Bean并发重复创建
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
// 合并BeanDefinition，在之前的xml配置Bean的方式中，可以通过指定parent的方式继承父Bean的相关属性
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 如果类上存在@DependsOn注解，说明依赖其他Bean，需要先把依赖的Bean创建出来，再回来创建当前Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 判断是否存在循环依赖
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 维护Bean的依赖关系
registerDependentBean(dep, beanName);
try {
// 生成依赖Bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
// 获取单例Bean
sharedInstance = getSingleton(beanName, () -> {
try {
// 方法回调，用于实际创建Bean，核心方法
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
// 针对FactoryBean的情况，调用实现自FactoryBean的getObject()方法获取自定义Bean
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
// 原型Bean的情况下，每次创建新的Bean
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 创建Bean，核心方法
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 针对FactoryBean的情况，调用实现自FactoryBean的getObject()方法获取自定义Bean
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 要生成的Bean既不是singleton，也不是prototype类型
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// 执行Bean的创建
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
// 方法回调，用于实际创建Bean，核心方法
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
// 针对FactoryBean的情况，调用实现自FactoryBean的getObject()方法获取自定义Bean
beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
beanCreation.end();
}
}
// 如果Bean实例与要求的类型不一样，则调用TypeConverter#convertIfNecessary()方法进行转换，
// 若一样则直接返回实例
return adaptBeanInstance(name, beanInstance, requiredType);
}AbstractAutowireCapableBeanFactory#createBean()
该方法的核心步骤为：
1.取得当前BeanDefinition的Class；
2.执行当前类实现的InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()方法（Bean实例化前）；
如果得到了Bean，则接着执行当前类实现的InstantiationAwareBeanPostProcessor#postProcessAfterInitialization()方法
3.若步骤2未创建Bean，则调用AbstractAutowireCapableBeanFactory#doCreateBean()方法进行Bean的创建。
核心源码如下：
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 省略日志输出代码...
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 取得类的Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 省略部分代码...
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 执行当前类实现的InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()方法
// 如果得到了Bean，则接着执行当前类实现的InstantiationAwareBeanPostProcessor#postProcessAfterInitialization()方法
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
// 省略异常捕获代码...
try {
// 执行Bean的创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
// 省略日志输出代码
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// 省略异常捕获代码...
}AbstractAutowireCapableBeanFactory#doCreateBean()
此方法囊括了Bean的实例化、属性填充、Bean销毁注册的核心步骤，核心源码如下：
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 实例化，核心步骤
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 省略部分代码...
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// BeanDefinition扩展点，执行的是MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition()方法
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
// 省略异常处理代码...
mbd.postProcessed = true;
}
}
// 省略部分代码...
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 属性填充，核心步骤
populateBean(beanName, mbd, instanceWrapper);
// 初始化，核心步骤
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
// 省略部分代码...
// Register bean as disposable.
try {
// 注册销毁对象，供Bean的销毁使用
// 构造DisposableBeanAdapter对象，存在到DefaultSingletonBeanRegistry的属性disposableBeans中
// 当Spring容器关闭时会执行DisposableBeanAdapter的destroy()方法，进行Bean的销毁
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}2.1 实例化
Bean的实例化是通过调用AbstractAutowireCapableBeanFactory#createBeanInstance()方法实现的，其步骤为：
1.取得当前BeanDefinition的Class；
2.如果当前类实现了Supplier接口，则调用实现自接口Supplier的get()方法获取Bean并返回；
3.如果BeanDefinition中指定了factoryMethod，则调用AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod()方法进行Bean的创建并返回；
4.推断构造方法
由于推断构造方法及利用推断出来的构造方法创建Bean流程较长，将在另外的文章中进行分析。
5.使用默认方法创建Bean
核心源码如下：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 省略部分代码...
// 实现了Supplier接口，则调用实现自接口Supplier的get()方法获取Bean
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// BeanDefinition中指定了factoryMethod，则使用指定的factoryMethod方法进行Bean的创建
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 省略部分代码...
// Candidate constructors for autowiring?
// 推断构造方法
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 使用默认构造方法创建Bean
return instantiateBean(beanName, mbd);
}2.2 属性赋值
属性填充，即依赖注入，此步骤对应的是AbstractAutowireCapableBeanFactory#populateBean()方法。对应两个核心步骤：
1.提供InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()的扩展点，用于在Bean实例化完成后进行一些扩展。
2.进行属性填充，通过此步骤我们将知道@Autowired、@Value、@Resource的底层逻辑。
由于此阶段对应流程较为复杂，将在后续文章中进行深入分析。
2.3 初始化
初始化阶段有四个核心步骤：
1.执行Aware
Spring通过此步骤给Bean设置了以下内容：
①BeanNameAware：回传beanName给bean对象；
②BeanClassLoaderAware：回传classLoader给bean对象；
③BeanFactoryAware：回传beanFactory给对象。
2.执行初始化前方法，即BeanPostProcessor#postProcessBeforeInitialization()方法
利用初始化前，可以对进行了依赖注入的Bean进行处理。
在Spring源码中：
①InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法，对应CommonAnnotationBeanPostProcessor#postProcessBeforeInitialization()方法；
②ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：
EnvironmentAware：回传环境变量
EmbeddedValueResolverAware：回传占位符解析器
ResourceLoaderAware：回传资源加载器
ApplicationEventPublisherAware：回传事件发布器
MessageSourceAware：回传国际化资源
ApplicationStartupAware：回传应用其他监听对象，可忽略
ApplicationContextAware：回传ApplicationContext容器
3.执行初始化方法，
如果类实现了InitializingBean接口，则调用实现自InitializingBean的方法afterPropertiesSet()；
如果BeanDefinition指定了初始化方法，则调用指定的初始化方法。
4.执行初始化后方法，即BeanPostProcessor#postProcessAfterInitialization()方法
可以在这个步骤对Bean最终进行处理，初始化后返回的对象才是最终的Bean对象，Spring中的AOP就是基于初始化后实现的。
核心源码如下：
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 执行Aware 将部分属性回传给Bean
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 执行初始化前方法，即BeanPostProcessor#postProcessBeforeInitialization()方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 初始化
// 如果类实现了InitializingBean接口，则调用实现自InitializingBean的方法afterPropertiesSet()；
// 如果BeanDefinition指定了初始化方法，则调用指定的初始化方法。
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()) {
// 执行初始化后方法，即BeanPostProcessor#postProcessAfterInitialization()方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}2.4 销毁
Bean的销毁是在Spring容器关闭时进行的。Bean的创建阶段，在AbstractAutowireCapableBeanFactory#doCreateBean()阶段构建Bean的DisposableBeanAdapter对象，添加到了DefaultSingletonBeanRegistry的属性disposableBeans中；Bean的销毁阶段，在DefaultSingletonBeanRegistry#destroyBean()方法中调用了DisposableBeanAdapter#destroy()方法，进行Bean的销毁。
销毁阶段比较明了，其方法调用链为：
AbstractApplicationContext#close() ——> AbstractApplicationContext#doClose() ——> AbstractApplicationContext#destroyBeans() ——> DefaultListableBeanFactory#destroySingletons() ——> DefaultSingletonBeanRegistry#destroySingletons() ——> DefaultSingletonBeanRegistry#destroySingleton() ——> DefaultSingletonBeanRegistry#destroyBean() ——> DisposableBeanAdapter#destroy()
435
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
