【spring源码系列】之【Bean的销毁】
作者：互联网
以“冬奥之光，多彩冰灯”为主题的第四十一届全国专业冰雕比赛在冰城哈尔滨市进入第二天，60名冰雕高手在哈尔滨冰灯艺术游园会园区展开激烈的竞技比拼。
冰雕艺术
1. 概述
Bean的销毁是Bean的生命周期中最后一步，比如在Tomcat等容器关闭的时候会调用Bean的销毁方法，下面逐步分析。
2. 源码分析
在bean创建完成后，就会对这个bean注册一个销毁的Adapter对象，
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
......
if (instanceWrapper == null) {
//创建对象实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
......
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);
}
}
......
// Register bean as disposable.
try {
// 注册销毁的bean
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
registerDisposableBeanIfNecessary方法中disposableBeans集合负责收集需要销毁的bean。
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
// 注册销毁bean的DisposableBeanAdapter对象
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
......
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
DisposableBeanAdapter 对象就是负责 bean 销毁的类，这个类中收集 bean是否实现了 DisposableBean 接口
class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable
是否配置 destroy-method 属性，过滤了 DestructionAwareBeanPostProcessor 类型的接口，如下图所示：
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
......
this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
}
private List<DestructionAwareBeanPostProcessor> filterPostProcessors(List<BeanPostProcessor> processors, Object bean) {
List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
if (!CollectionUtils.isEmpty(processors)) {
filteredPostProcessors = new ArrayList<>(processors.size());
for (BeanPostProcessor processor : processors) {
if (processor instanceof DestructionAwareBeanPostProcessor) {
DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
if (dabpp.requiresDestruction(bean)) {
filteredPostProcessors.add(dabpp);
}
}
}
}
return filteredPostProcessors;
然后 bean 是在什么时候被销毁呢，在 tomcat 关闭的时候就会调用到 servlet 中的销毁方法，具体是通过类ContextLoaderListener.java 中的contextDestroyed 方法，通过 closeWebApplicationContext 方法一直往下找此为 servlet 规范的使用，一路往下调用。
最终会进入DisposableBeanAdapter类中的destroy，方法该方法就会根据前面的收集进行调用。
public void destroy() {
// 处理@PreDestroy注解的beanpostProcessor实现类: InitDestroyAnnotationBeanPostProcessor
if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
processor.postProcessBeforeDestruction(this.bean, this.beanName);
}
}
// 处理实现DisposableBean接口的bean的销毁
if (this.invokeDisposableBean) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
}
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((DisposableBean) this.bean).destroy();
return null;
}, this.acc);
}
else {
((DisposableBean) this.bean).destroy();
}
}
catch (Throwable ex) {
String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
}
else {
logger.warn(msg + ": " + ex);
}
}
}
// 处理在配置文件中的bean配置了destroy-method的bean的销毁
if (this.destroyMethod != null) {
invokeCustomDestroyMethod(this.destroyMethod);
}
else if (this.destroyMethodName != null) {
Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
if (methodToInvoke != null) {
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
}
}
}
销毁bean的顺序是如下：
1）判断是否需要处理@PreDestroy注解的bean，如果需要，则通过beanpostProcessor实现类 InitDestroyAnnotationBeanPostProcessor处理；
2）判断是否需要处理实现DisposableBean接口的bean的销毁；
3）判断是否需要处理配置文件中的bean配置了destroy-method的bean的销毁。
3. 案例演示
定义Bean，同时加入销毁对应的三种方法；
/**
* @Author: wzj
* @Date: 2021/7/2 11:32
* @Desc:
*/
public class Wzj implements DisposableBean {
public static Wzj factoryMethod() {
CQ cq = new CQ();
SC sc = new SC();
return new Wzj(sc, cq);
}
@PreDestroy
public void close() {
System.out.println("通过 @PreDestroy：销毁实例wzj");
}
public void destroyMethod() {
System.out.println("通过配置文件配置destroy-method：销毁实例wzj");
}
@Override
public void destroy() {
System.out.println("通过DisposableBean接口：销毁实例wzj");
}
配置文件如下：
<bean id="wzj" class="com.wzj.bean.Wzj" factory-method="factoryMethod" destroy-method="destroyMethod"/>
测试类：
/**
* @Author: wzj
* @Date: 2021/3/30 15:08
* @Desc: 测试类
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring.xml"})
public class TestSpring {
@Autowired
private ApplicationContext applicationContext;
@Test
public void testDestroy() {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
Wzj wzj = (Wzj)applicationContext.getBean("wzj");
applicationContext.getBeanFactory().destroyBean("wzj");
}
结果:
有人可能会问，为何Bean可以多次销毁，其实Bean的销毁并不是真正意义上的销毁Bean，而是在销毁前执行销毁方法，可能包含关闭数据库连接、关闭网络请求等逻辑操作，而后真正的销毁是由Spring容器执行关闭，其内部Bean也就自然而然消失了，Bean销毁是发生在Spring容器关闭过程中的。
标签：销毁,mbd,spring,beanName,bean,Bean,源码,destroy,DisposableBean 来源： https://www.cnblogs.com/father-of-little-pig/p/15962244.html