首先Bean就是一些JAVA对象,只不过这些Bean不是我们主动new
出来的,而是交个Spring IOC容器创建并管理的,因此Bean的生命周期受Spring IOC容器控制,Bean生命周期大致分为以下几个阶段:
Bean的实例化(Instantiation):Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的,是否不是延迟加载的,是否不是FactoryBean等,最终将一个普通的singleton的Bean通过反射进行实例化
Bean的属性赋值(Populate):Bean实例化之后还仅仅是个"半成品",还需要对Bean实例的属性进行填充,Bean的属性赋值就是指 Spring 容器根据BeanDefinition中属性配置的属性值注入到 Bean 对象中的过程。
Bean的初始化(Initialization):对Bean实例的属性进行填充完之后还需要执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段,并且Spring高频面试题Bean的循环引用问题也是在这个阶段体现的;
Bean的使用阶段:经过初始化阶段,Bean就成为了一个完整的Spring Bean,被存储到单例池singletonObjects中去了,即完成了Spring Bean的整个生命周期,接下来Bean就可以被随心所欲地使用了。
Bean的销毁(Destruction):Bean 的销毁是指 Spring 容器在关闭时,执行一些清理操作的过程。在 Spring 容器中, Bean 的销毁方式有两种:销毁方法destroy-method和 DisposableBean 接口。
BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor,BeanPostProcessor
这三个后置处理器的调用时机都在Spring Bean生命周期中是不严谨的,按照上面我们对Bean生命周期的阶段划分,只有BeanPostProcessor
作用于Bean的生命周期中,而BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor
是针对BeanDefinition的,所以不属于Bean的生命周期中。
BeanPostProcessor
在Bean生命周期的体现如下图所示:
Bean的生命周期和人的一生一样都会经历从出生到死亡,中间是一个漫长且复杂的过程,接下来我们就来整体分析一下Bean生命周期的核心流程和相关接口回调方法的调用时机,同时这里想强调一下Bean的生命周期也是面试的高频考点,对核心流程务必要掌握清楚,这里用一张流程图进行详述展示,是重点、重点、重点。
根据上面的Bean生命周期核心流程做如下代码演示示例:
Bean定义:
@Data
@AllArgsConstructor
public class Boo implements InitializingBean, DisposableBean, BeanNameAware {
private Long id;
private String name;
public Boo() {
System.out.println("boo实例化构造方法执行了...");
}
@PostConstruct
public void initMethod() {
System.out.println("boo执行初始化init()方法了...");
}
@PreDestroy
public void destroyMethod() {
System.out.println("boo执行初始化destroy()方法了...");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("boo执行InitializingBean的afterPropertiesSet()方法了...");
}
@Override
public void destroy() throws Exception {
System.out.println("boo执行DisposableBean的destroy()方法了...");
}
@Override
public void setBeanName(String name) {
System.out.println("boo执行BeanNameAware的setBeanName()方法了...");
}
}
实现InstantiationAwareBeanPostProcessor:
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> BeanClass, String BeanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor的before()执行了...." + BeanName);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object Bean, String BeanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor的after()执行了...." + BeanName);
return false;
}
}
实现BeanPostProcessor:
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object Bean, String BeanName) throws BeansException {
System.out.println("BeanPostProcessor的before()执行了...." + BeanName);
return Bean;
}
@Override
public Object postProcessAfterInitialization(Object Bean, String BeanName) throws BeansException {
System.out.println("BeanPostProcessor的after()执行了...."+ BeanName);
return Bean;
}
}
执行下面的配置类测试方法:
@ComponentScan(basePackages = {"com.shepherd.common.config"})
@Configuration
public class MyConfig {
@Bean
public Boo boo() {
return new Boo();
}
public static void mAIn(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
String[] BeanDefinitionNames = applicationContext.getBeanDefinitionNames();
// 遍历Spring容器中的BeanName
for (String BeanDefinitionName : BeanDefinitionNames) {
System.out.println(BeanDefinitionName);
}
// 这里调用的applicationContext的close()触发Bean的销毁回调方法
applicationContext.close();
}
}
名为boo的Bean相关运行结果如下:
InstantiationAwareBeanPostProcessor的before()执行了....boo
boo实例化构造方法执行了...
InstantiationAwareBeanPostProcessor的after()执行了....boo
boo执行BeanNameAware的setBeanName()方法了...
BeanPostProcessor的before()执行了....boo
boo执行初始化init()方法了...
boo执行InitializingBean的afterPropertiesSet()方法了...
BeanPostProcessor的after()执行了....boo
......
boo执行初始化destroy()方法了...
boo执行DisposableBean的destroy()方法了...
根据控制台打印结果可以boo的相关方法执行顺序严格遵从上面流程图,同时当我们执行容器applicationContext
的关闭方法close()
会触发调用bean的销毁回调方法。
DefaultListableBeanFactory
是Spring IOC的Bean工厂的一个默认实现,IOC大部分核心逻辑实现都在这里,可关注。Bean生命周期就是创建Bean的过程,这里我们就不在拐弯抹角兜圈子,直接来到DefaultListableBeanFactory
继承的AbstractAutowireCapableBeanFactory
的#doCreateBean()
方法,之前说过在Spring框架中以do开头的方法都是核心逻辑实现所在
protected Object doCreateBean(String BeanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the Bean.
// BeanWrapper 是对 Bean 的包装,其接口中所定义的功能很简单包括设置获取被包装的对象,获取被包装 Bean 的属性描述器
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// <1> 单例模型,则从未完成的 FactoryBean 缓存中删除
instanceWrapper = this.factoryBeanInstanceCache.remove(BeanName);
}
if (instanceWrapper == null) {
// <2> 使用合适的实例化策略来创建新的实例:工厂方法、构造函数自动注入、简单初始化
instanceWrapper = createBeanInstance(BeanName, mbd, args);
}
// 包装的实例对象
Object Bean = instanceWrapper.getWrappedInstance();
// 包装的实例class类型
Class<?> BeanType = instanceWrapper.getWrappedClass();
if (BeanType != NullBean.class) {
mbd.resolvedTargetType = BeanType;
}
// Allow post-processors to modify the merged Bean definition.
// <3> 判断是否有后置处理
// 如果有后置处理,则允许后置处理修改 BeanDefinition
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;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// <4> 解决单例模式的循环依赖
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");
}
// 提前将创建的 Bean 实例加入到 singletonFactories 中
// 这里是为了后期避免循环依赖
addSingletonFactory(BeanName, () -> getEarlyBeanReference(BeanName, mbd, Bean));
}
// Initialize the Bean instance.
// 开始初始化 Bean 实例对象
Object exposedObject = Bean;
try {
// <5> 对 Bean 进行填充,将各个属性值注入,其中,可能存在依赖于其他 Bean 的属性
// 则会递归初始依赖 Bean
populateBean(BeanName, mbd, instanceWrapper);
// <6> 调用初始化方法
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);
}
}
// <7> 循环依赖处理
if (earlySingletonExposure) {
// 获取 earlySingletonReference
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);
}
}
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.");
}
}
}
}
// Register Bean as disposable.
try {
// <8> 注册 Bean的销毁逻辑
registerDisposableBeanIfNecessary(BeanName, Bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), BeanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
由上面代码可知,Bean的创建过程核心步骤如下:
接下来我们就来看看和Bean初始化阶段相关各种回调事件执行方法#initializeBean()
,分析一下上面流程图的执行顺序是怎么实现的。
protected Object initializeBean(final String BeanName, final Object Bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
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-methods
// 或者是实现了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初始化类似,从上面的使用示例中看可以得出当容器关闭时,才会对Bean销毁方法进行调用。销毁过程是这样的。顺着close()-> doClose() -> destroyBeans() -> destroySingletons() -> destroySingleton() -> destroyBean() -> Bean.destroy()
,会看到最终调用Bean的销毁方法。这里就不在展示源码细节啦,有兴趣的话自行去调试查看了解
以上全部就是对Spring Bean生命周期的全面总结, Spring 的 Bean 容器机制是非常强大的,它可以帮助我们轻松地管理 Bean 对象,并且提供了丰富的生命周期回调方法,允许我们在 Bean 的生命周期中执行自己的特定操作,这对于我们平时工作使用中进行增强扩展至关重要,因此掌握Bean的生命周期是必须的。