foreword

What we are talking about here is the destruction process of Bean. Perhaps, when many friends talk about the destruction of Beans, they may think of garbage collection. Although both are doing the last part of the life cycle, they are actually not the same thing.Garbage collection is a JVM-level thing, and the Bean destruction mentioned here is a Spring thing, so of course it's not the same thing.

reading advice

The content of this lesson will be explained with the following code as the entry point:

		// 注册Bean的销毁接口
		try {
    
    
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
    
    
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;

This code is actually in the method of Spring instantiation AbstractAutowireCapableBeanFactory#doCreateBean(). Moreover, everyone knows the name of this method. This step is just to register the destruction logic, not the real destruction. Only when certain conditions are met will it be destroyed.
registerDisposableBeanIfNecessaryThe specific code is as follows:

  /**
     * 将给定bean添加到此工厂中的一次性bean列表中，注册其DisposableBean接口和/或给定的destroy方法，以便在工厂关闭时调用(如果适用)。只适用于单例。 
     * 参数: 
     * beanName—bean的名称—bean实例mbd—bean的bean定义 
     * 参见: 
     * RootBeanDefinition。isSingleton RootBeanDefinition。getDependsOn, registerDisposableBean, registerDependentBean
     */
    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.
                registerDisposableBean(beanName, new DisposableBeanAdapter(
                        bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            } else {
    
    
                // A bean with a custom scope...
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
    
    
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
                        bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            }
        }
    }

Course content

1. When will the Bean be destroyed?

Bean destruction occurs during the shutdown of the Spring container. At this time, all singleton beans in Spring will be destroyed, and the destruction methods of the beans that implement the custom destruction logic will be executed. What we are going to introduce in this article is: how to implement custom Bean destruction logic .
When the Spring container is closed, it can be displayed closed, such as:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

// 容器关闭
context.close();

Alternatively, register a shutdown hook:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 注册关闭钩子
context.registerShutdownHook();

Object newUser = context.getBean("user");
System.out.println(newUser);

[Note: Forcibly killing the process (kill pid) will not call the custom Bean destruction logic]

The process of Spring closing the container:

First publish the ContextClosedEvent event
Call the onCloese() method of lifecycleProcessor
Destroy the singleton bean
- Iterating over disposableBeans
  - Remove each disposableBean from the singleton pool
  - Call the destroy() of the disposableBean
  - If this disposableBean is also dependent on other beans, then other beans must also be destroyed
  - If this disposableBean also contains inner beans, remove these beans from the singleton pool
- Clear manualSingletonNames, which is a Set, which stores the beanName of the singleton bean manually registered by the user
- Clear allBeanNamesByType, it is a Map, the key is the bean type, and the value is an array of all beanNames of this type
- Empty singletonBeanNamesByType, similar to allBeanNamesByType, except that only singleton Bean is saved

2. Implement custom Bean destruction logic

The implementation methods are as follows:

2.1 Implement DisposableBean or AutoCloseable interface

Bean code example that requires custom destruction: (implemented from: DisposableBean)

@Component
public class TestDestroyBean implements DisposableBean {
    
    
    public void test() {
    
    
        System.out.println("测试一下销毁方法");
    }

    @Override
    public void destroy() throws Exception {
    
    
        System.out.println("TestDestroyBean------自定义的Bean销毁方法");
    }
}

Or: (implemented from: AutoCloseable)

@Component
public class TestDestroyBean implements AutoCloseable {
    
    
    public void test() {
    
    
        System.out.println("测试一下销毁方法");
    }
    
    @Override
    public void close() throws Exception {
    
    
        System.out.println("TestDestroyBean------自定义的Bean销毁方法");
    }
}

2.2 Using the @PreDestroy annotation

There are three implementation methods:

@Component
public class TestDestroyBean {
    
    
    public void test() {
    
    
        System.out.println("测试一下销毁方法");
    }

    @PreDestroy
    public void close() throws Exception {
    
    
        System.out.println("TestDestroyBean------自定义的Bean销毁方法");
    }
}

2.3 Other methods (manually specify the name of the destruction method)

Of course, there are other ways, such as:

<bean destroy-method='xxx'>

or:

@Bean(destroyMethod = "xxx")

Or, beanDefinitionspecify the destruction method directly in it:

@Component
public class MyBeanPostProcessor implements MergedBeanDefinitionPostProcessor {
    
    
    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    
    
        if (beanName.equals("user")) {
    
    
            beanDefinition.setInitMethodName("myInit");
            beanDefinition.setDestroyMethodName("xxxx");
        }
    }
}

The three methods mentioned above have a special place, because they are manually specified, so you can set a special value: (inferred).
If the name of the destruction method is set to this, and the bean is not implemented DisposableBean, then, during the destruction process, it will be checked whether there is a method closeor not under the bean shutdown. If yes, it will be automatically bound to 【User-defined Destruction Method】.