Spring Bean的生命周期
一、引言
Spring Bean
的生命周期流程图
其实要记忆该过程,还是需要我们先去理解,本文将从以下两方面去帮助理解Bean
的生命周期:
- 生命周期的概要流程:对
Bean
的生命周期进行概括,并且结合代码来理解; - 扩展点的作用:详细介绍
Bean
生命周期中所涉及到的扩展点的作用。
二、生命周期的概要流程
Bean
的生命周期概括起来就是4
个阶段:
- 实例化(Instantiation)
- 属性赋值(Populate)
- 初始化(Initialization)
- 销毁(Destruction)
- 实例化:第
1
步,实例化一个bean
对象; - 属性赋值:第
2
步,为bean
设置相关属性和依赖; - 初始化:第
3~7
步,步骤较多,其中第5、6
步为初始化操作,第3、4
步为在初始化前执行,第7
步在初始化后执行,该阶段结束,才能被用户使用; - 销毁:第
8~10
步,第8
步不是真正意义上的销毁(还没使用呢),而是先在使用前注册了销毁的相关调用接口,为了后面第9、10
步真正销毁bean
时再执行相应的方法。
下面我们结合代码来直观的看下,在doCreateBean()
方法中能看到依次执行了这4
个阶段:
// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd,
final @Nullable Object[] args)
throws BeanCreationException {
// 1. 实例化
BeanWrapper instanceWrapper = null;
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object exposedObject = bean;
try {
// 2. 属性赋值
populateBean(beanName, mbd, instanceWrapper);
// 3. 初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
// 4. 销毁-注册回调接口
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
return exposedObject;
}
由于初始化包含了第3~7
步,较复杂,所以我们进到initializeBean()
方法里具体看下其过程(注释的序号对应图中序号):
// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean,
@Nullable RootBeanDefinition mbd) {
// 3. 检查Aware相关接口并设置相关依赖
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
// 4. BeanPostProcessor前置处理
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// 5. 若实现InitializingBean接口,调用afterPropertiesSet()方法
// 6. 若配置自定义的init-method方法,则执行
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
// 7. BeanPostProceesor后置处理
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
在invokInitMethods()
方法中会检查InitializingBean
接口和init-method
方法,销毁的过程也与其类似:
// DisposableBeanAdapter.java
public void destroy() {
// 9. 若实现 DisposableBean 接口,则执行 destory()方法
if (this.invokeDisposableBean) {
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((DisposableBean) this.bean).destroy();
return null;
}, this.acc);
}
else {
((DisposableBean) this.bean).destroy();
}
}
}
// 10. 若配置自定义的 detory-method 方法,则执行
if (this.destroyMethod != null) {
invokeCustomDestroyMethod(this.destroyMethod);
}
else if (this.destroyMethodName != null) {
Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
if (methodToInvoke != null) {
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
}
}
从Spring
的源码我们可以直观的看到其执行过程,而我们记忆其过程便可以从这4
个阶段出发,实例化、属性赋值、初始化、销毁。其中细节较多的便是初始化,涉及了Aware
、BeanPostProcessor
、InitializingBean
、init-method
的概念。这些都是Spring
提供的扩展点,其具体作用将在下一节讲述。
三、扩展点的作用
3.1 Aware接口
若Spring
检测到bean
实现了Aware
接口,则会为其注入相应的依赖。所以通过让bean
实现Aware
接口,则能在bean
中获得相应的Spring
容器资源 。
Spring
中提供的Aware
接口有:
BeanNameAware
:注入当前bean
对应beanName
;BeanClassLoaderAware
:注入加载当前bean
的ClassLoader
;BeanFactoryAware
:注入当前BeanFactory
容器的引用。
其代码实现如下:
// AbstractAutowireCapableBeanFactory.java
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
以上是针对BeanFactory
类型的容器,而对于ApplicationContext
类型的容器,也提供了Aware
接口,只不过这些Aware
接口的注入实现,是通过BeanPostProcessor
的方式注入的,但其作用仍是注入依赖。
EnvironmentAware
:注入Enviroment
,一般用于获取配置属性;EmbeddedValueResolverAware
:注入EmbeddedValueResolver
(Spring EL
解析器),一般用于参数解析;ApplicationContextAware
(ResourceLoader
、ApplicationEventPublisherAware
、MessageSourceAware
):注入ApplicationContext
容器本身。
其代码实现如下:
// ApplicationContextAwareProcessor.java
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware)bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
}
}
3.2 BeanPostProcessor
BeanPostProcessor
是Spring
为修改bean
提供的强大扩展点,其可作用于容器中所有bean
,其定义如下:
public interface BeanPostProcessor {
// 初始化前置处理
default Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
// 初始化后置处理
default Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
}
常用场景有:
- 对于标记接口的实现类,进行自定义处理。例如3.1节中所说的
ApplicationContextAwareProcessor
,为其注入相应依赖;再举个例子,自定义对实现解密接口的类,将对其属性进行解密处理; - 为当前对象提供代理实现。例如
Spring AOP
功能,生成对象的代理类,然后返回。
// AbstractAutoProxyCreator.java
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass,
beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
// 返回代理类
return proxy;
}
return null;
}
3.3 InitializingBean和init-method
InitializingBean
和init-method
是Spring
为bean
初始化提供的扩展点。
InitializingBean
接口的定义如下:
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
在afterPropertiesSet()
方法写初始化逻辑。
指定init-method
方法,指定初始化方法:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="demo" class="com.test.Demo" init-method="init()"/>
</beans>
DisposableBean
和destory-method
与上述类似,就不描述了。
四、总结
最后总结下如何记忆Spring Bean
的生命周期:
- 首先是实例化、属性赋值、初始化、销毁这
4
个大阶段; - 再是初始化的具体操作,有
Aware
接口的依赖注入、BeanPostProcessor
在初始化前后的处理以及InitializingBean
和init-method
的初始化操作; - 销毁的具体操作,有注册相关销毁回调接口,最后通过
DisposableBean
和destory-method
进行销毁。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器