前言
Spring Bean 是 Spring IOC 容器负责实例化、组装和管理的对象，它和普通的 Java 对象并没有什么区别，唯一的区别就是它不是由开发人员自己 new 出来的，而是由容器负责创建的。IOC 容器除了实例化对象，还会负责管理对象之间的依赖关系，自动注入依赖和属性，甚至创建代理对象来对原始对象进行增强。
生命周期是一个对象从创建到被销毁经历的整个过程，普通Java对象的生命周期是JVM分配内存，调用构造函数实例化对象，当该对象没有被引用后再由GC负责销毁并释放内存。而 Spring Bean 是由IOC容器负责创建和管理的对象，它的生命周期相比普通Java对象会更加复杂。
生命周期
Spring Bean 的生命周期简单来说可以划分为五大阶段：实例化 -> 属性赋值 -> 初始化 -> 对外服务 -> 销毁。
实例化
生命周期的第一阶段是实例化，Spring 首先得要有Bean的定义才知道该如何实例化，这个Bean的定义就是 BeanDefinition。不论是通过@Component 注解定义的Bean，还是通过xml配置的Bean，Spring 最终都会把它们解析并封装成 BeanDefinition 对象。
Spring 创建Bean的入口是AbstractAutowireCapableBeanFactory#createBean ，这里会触发扩展点 InstantiationAwareBeanPostProcessor，给BeanPostProcessor一个返回代理对象的机会，跳过 Spring Bean 的创建流程。如果扩展点没有返回代理对象就会调用doCreateBean() 创建Bean。
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
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 {
/**
* 调用InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
* 给BeanPostProcessor一个返回代理对象的机会，跳过Spring 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);
}
try {
// 创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
在doCreateBean() 里首先会调用createBeanInstance() 实例化Bean，有三种方式：
- 调用 instanceSupplier 实例化
- 触发 factoryMethodName 实例化
- 推断构造函数，反射调用实例化
紧接着调用populateBean() 完成属性填充、注入依赖，再是initializeBean() 初始化Bean，最后是把Bean注册到disposableBeans 在容器销毁时触发destroy-method。
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) {
// 实例化bean
instanceWrapper = 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 {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
Object exposedObject = bean;
try {
// 属性填充
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean
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);
if (earlySingletonReference != null) {
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);
}
}
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 {
// 必要时注册到disposableBeans，容器销毁时调用destroy-method
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
属性填充
生命周期的第二阶段是属性填充，在填充前 Spring 得知道要为Bean填充哪些属性，所以会先触发 MergedBeanDefinitionPostProcessor 扩展点收集填充的元数据 InjectionMetadata，包含被@Autowired、@Value、@Resource注解的属性或方法。还有生命周期方法元数据 LifecycleMetadata，也就是Bean的 init-method、destroy-method等。
元数据收集完毕后，开始调用populateBean() 填充属性。属性填充前，会触发扩展点InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation 返回值告诉 Spring 是否要继续填充属性，默认返回 true。之后会调用InstantiationAwareBeanPostProcessor#postProcessProperties 扩展点来填充属性。
以 AutowiredAnnotationBeanPostProcessor 为例，它会收集被@Autowired注解的方法和属性元数据，并且注入对应的属性值。
初始化
生命周期的第三阶段是初始化，initializeBean() 首先会触发几个Aware接口方法，然后触发BeanPostProcessor#postProcessBeforeInitialization 扩展点，接着触发 init-method，如果Bean实现了InitializingBean接口，会再触发InitializingBean#afterPropertiesSet ，最后触发BeanPostProcessor#postProcessAfterInitialization 扩展点。
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 {
// 触发BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 扩展点 BeanPostProcessor#postProcessBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 执行init方法 InitializingBean#afterPropertiesSet
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;
}
对外服务
初始化以后，Bean就是一个完整可用的Bean了，此时就可以正常对外服务了。
销毁
生命周期的第五阶段是销毁，ConfigurableApplicationContext 在close时会触发destroyBeans() ，它会遍历 disposableBeans 并调用DisposableBeanAdapter#destroy ，如果Bean实现了DisposableBean接口，则调用DisposableBean#destroy ；如果Bean实现了AutoCloseable接口，则调用AutoCloseable#close ；如果Bean指定了destroyMethod，则触发对应的销毁方法。
至此，Spring Bean的整个生命周期就结束了，为了便于记忆，画了个脑图
尾巴
Spring Bean的生命周期大致可以分为：实例化 -> 属性填充 -> 初始化 -> 对外服务 -> 销毁 五个阶段。Spring 会把 BeanClass或者xml配置解析成BeanDefinition，根据定义会有三种实例化Bean的方式，Bean的实例化前后会有对应的扩展点。实例化完成以后，Spring 会触发扩展点来收集要注入的元数据和生命周期方法元数据，然后调用扩展点完成属性注入。之后就是初始化节点，会先触发几个Aware接口方法，再触发BeanPostProcessor前置扩展点，然后执行 init-method，接着触发BeanPostProcessor后置扩展点，Bean就可以对外提供服务了。最后在容器关闭时，Spring 还会调用Bean的销毁方法，整个生命周期就结束了。
