代码拉取完成，页面将自动刷新
同步操作将从 xuchengsheng/spring-reading 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
✒️ 作者 - Lex 📝 博客 - 我的CSDN 📚 文章目录 - 所有文章 🔗 源码地址 - @PreDestroy源码
@PreDestroy 注解来源于 JSR-250（Java Specification Request 250），这是一个定义了一些常用的Java EE注解的规范。这些注解的目的是提供一个与平台无关的方式，允许我们定义一些生命周期事件，比如在bean销毁之后要执行的方法。
@PreDestroy 是 Java EE 提供的一个标准注解，表示被标记的方法应该在对象销毁后立即执行。
@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
}
@PreDestroy 方法中关闭这些连接，确保资源被正确释放。@PreDestroy 方法中执行这些清理操作。@PreDestroy 方法来实现这一点。@PreDestroy 方法中做这个工作。@PreDestroy 方法中执行此操作。destroy-method XML 属性相比，使用 @PreDestroy 注解使代码更清晰，因为清理逻辑和 bean 代码位于同一位置，而无需查看 XML 配置文件。首先来看看启动类入口，上下文环境使用AnnotationConfigApplicationContext（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个MyConfiguration组件类，最后调用context.close()方法关闭容器。
public class PreDestroyApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
context.close();
}
}
在MyConfiguration类中，使用了@ComponentScan("com.xcs.spring")注解告诉 Spring 在指定的包（在这里是 "com.xcs.spring"）及其子包中搜索带有 @Component、@Service、@Repository 和 @Controller 等注解的类，并将它们自动注册为 beans。这样，spring就不必为每个组件明确写一个 bean 定义。Spring 会自动识别并注册它们。
@Configuration
@ComponentScan("com.xcs.spring")
public class MyConfiguration {
}
MyService 的 Spring Service 类。这个类有一个无参构造函数和一个使用 @PreDestroy 注解的方法。
@Service
public class MyService {
public MyService(){
System.out.println("执行MyService构造函数");
}
@PreDestroy
public void preDestroy(){
System.out.println("执行@PreDestroy方法");
}
}
运行结果发现，关闭上下文时 @PreDestroy 方法会被调用。
执行MyService构造函数
执行@PreDestroy方法
在Spring中，InitDestroyAnnotationBeanPostProcessor是处理@PreDestroy等注解的关键类，它实现了下述两个接口。因此，为了深入理解@PreDestroy的工作方式，研究这个类是非常有用的。简而言之，为了完全理解@PreDestroy的工作机制，了解下述接口确实是必要的。这两个接口提供了对bean生命周期中关键阶段的干预，从而允许进行方法执行和其他相关的操作。
MergedBeanDefinitionPostProcessor接口
postProcessMergedBeanDefinition方法允许后处理器修改合并后的bean定义。合并后的bean定义是一个已经考虑了所有父bean定义属性的bean定义。对于@PreDestroy注解的处理，这一步通常涉及到收集需要被解析的@PreDestroy注解信息并准备对其进行后续处理。DestructionAwareBeanPostProcessor接口
@PreDestroy 注解，InitDestroyAnnotationBeanPostProcessor 在这个方法中确保标注了 @PreDestroy 的方法在 bean 被销毁之前被执行。在org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition方法中，首先调用了 super.postProcessMergedBeanDefinition，即调用了父类或接口默认的实现。
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
// ... [代码部分省略以简化]
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessMergedBeanDefinition方法中，主要是处理与 @PreDestroy 注解相关的资源注入元数据，并在bean定义合并后对这些元数据进行进一步的处理或验证。这是Spring在处理JSR-250 @PreDestroy 注解时的处理入口。
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
// 根据给定的bean类型查找与其相关的生命周期元数据。
LifecycleMetadata metadata = findLifecycleMetadata(beanType);
// 使用找到的生命周期元数据来检查并可能修改给定的bean定义。
metadata.checkConfigMembers(beanDefinition);
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#findLifecycleMetadata方法中，首先尝试从缓存中获取 LifecycleMetadata，如果它不存在或需要刷新，则会创建新的 LifecycleMetadata 并将其存入缓存。这种缓存策略可以提高效率，避免对同一类型的类反复构建注入元数据。
private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
// 检查生命周期元数据缓存是否为空，这可能发生在反序列化或销毁阶段。
if (this.lifecycleMetadataCache == null) {
return buildLifecycleMetadata(clazz);
}
// 首先，在并发映射中进行快速检查，以最小的锁定。
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
// 如果缓存中没有找到元数据，则构建元数据并放入缓存。
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
// 双重检查锁定模式，确保只有一个线程构建和缓存元数据。
if (metadata == null) {
// 根据给定的类构建生命周期元数据。
metadata = buildLifecycleMetadata(clazz);
// 将新构建的元数据缓存，以便后续请求可以快速从缓存中检索。
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#buildLifecycleMetadata方法中，这个方法首先查看类是否有@PreDestroy注解，然后遍历类的方法以找到标记为生命周期方法的那些带有 @PreDestroy 注解的方法。找到的方法被存储在列表中，并在结束时根据这些方法构建一个 LifecycleMetadata 对象。
private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
// 判断给定的类是否有@PreDestroy注解。
if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
return this.emptyLifecycleMetadata;
}
// 存储识别出的初始化和销毁方法的列表。
List<LifecycleElement> destroyMethods = new ArrayList<>();
// ... [代码部分省略以简化]
Class<?> targetClass = clazz;
// 遍历目标类及其所有父类，直到达到Object类。
do {
final List<LifecycleElement> currInitMethods = new ArrayList<>();
final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
// 使用反射处理类的所有本地方法。
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// ... [代码部分省略以简化]
// 查找标有@PreDestroy注解的方法。
if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
currDestroyMethods.add(new LifecycleElement(method));
if (logger.isTraceEnabled()) {
logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
}
}
});
// 将当前类的生命周期方法添加到总列表中。
destroyMethods.addAll(currDestroyMethods);
// ... [代码部分省略以简化]
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
// 如果没有找到任何生命周期方法，则返回一个空的生命周期元数据对象；否则，返回新构建的元数据对象。
return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
new LifecycleMetadata(clazz, initMethods, destroyMethods));
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor.LifecycleElement#LifecycleElement方法中，它用于封装与生命周期相关的方法（如 @PreDestroy 注解的方法）。
public LifecycleElement(Method method) {
// 检查提供的方法是否是无参数的。生命周期方法（如@PreDestroy）需要是无参数方法。
if (method.getParameterCount() != 0) {
throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
}
// 存储提供的方法。
this.method = method;
// 根据方法的修饰符（如private）确定唯一标识符。如果方法是私有的，我们使用完全限定名，否则只使用方法名。
this.identifier = (Modifier.isPrivate(method.getModifiers()) ?
ClassUtils.getQualifiedMethodName(method) : method.getName());
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeDestruction方法中，实现了 postProcessBeforeDestruction 方法，它是 Spring 的 DestructionAwareBeanPostProcessor 接口的一部分，用于bean销毁之后要执行的方法。这个特定的实现与处理 @PreDestroy注解相关。
@Override
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeDestroyMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
// ... [代码部分省略以简化]
}
catch (Throwable ex) {
// ... [代码部分省略以简化]
}
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#findLifecycleMetadata方法中，首先InitDestroyAnnotationBeanPostProcessor#postProcessMergedBeanDefinition 元数据收集阶段，findLifecycleMetadata 被调用以处理和缓存与 @PreDestroy和其他相关注解的 LifecycleMetadata。这意味着，在postProcessBeforeDestruction阶段再次调用 findLifecycleMetadata 时，会直接从缓存中获取已处理的 LifecycleMetadata，而不需要重新构建它。
private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
// 检查生命周期元数据缓存是否为空，这可能发生在反序列化或销毁阶段。
if (this.lifecycleMetadataCache == null) {
return buildLifecycleMetadata(clazz);
}
// 首先，在并发映射中进行快速检查，以最小的锁定。
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
// 如果缓存中没有找到元数据，则构建元数据并放入缓存。
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
// 双重检查锁定模式，确保只有一个线程构建和缓存元数据。
if (metadata == null) {
// 根据给定的类构建生命周期元数据。
metadata = buildLifecycleMetadata(clazz);
// 将新构建的元数据缓存，以便后续请求可以快速从缓存中检索。
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor.LifecycleMetadata#invokeDestroyMethods方法中，主要负责在一个 bean 实例上调用销毁方法的地方。它基于预先确定的生命周期元素集合（这里是销毁方法集合）进行迭代，并对每个元素（方法）进行调用。
public void invokeDestroyMethods(Object target, String beanName) throws Throwable {
// 获取已经检查过的销毁方法集合
Collection<LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
// 根据是否存在已检查的销毁方法，选择要使用的销毁方法集合
Collection<LifecycleElement> destroyMethodsToUse =
(checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods);
// 判断是否有销毁方法需要执行
if (!destroyMethodsToUse.isEmpty()) {
// 遍历销毁方法集合
for (LifecycleElement element : destroyMethodsToUse) {
// 如果日志级别为 TRACE，记录正在调用的销毁方法信息
if (logger.isTraceEnabled()) {
logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
}
// 在目标 bean 上调用当前的销毁方法
element.invoke(target);
}
}
}
在org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor.LifecycleElement#invoke方法中，使用反射调用目标对象上的特定方法。
public void invoke(Object target) throws Throwable {
// 确保封装的方法是可访问的，特别是如果它是私有的。
ReflectionUtils.makeAccessible(this.method);
// 使用反射实际调用方法。由于该方法没有参数，所以传递一个null作为参数列表。
this.method.invoke(target, (Object[]) null);
}
@PreDestroy 的方法不应该有参数，并且应该是无返回值的（即返回 void）。@PreDestroy 的方法不应该抛出受检异常。如果在执行方法时出现任何错误或异常，建议在方法内部处理，以避免可能的未预期的行为。@PreDestroy，但最好确保方法是可访问的，特别是在子类或不同的包中。@PreDestroy 方法不会被 Spring 容器调用，因为 Spring 不管理原型 bean 的完整生命周期。因此，不要依赖 @PreDestroy 来清理原型 bean 的资源。@PreDestroy 注解的方法又有通过 XML destroy-method 属性指定的方法，那么 @PreDestroy 注解的方法将首先被调用，然后是 destroy-method 指定的方法。@PreDestroy 方法执行时仍然满足。@PreDestroy 方法的执行顺序，尤其是跨多个 bean 的情况。如果销毁方法之间的执行顺序很重要，我们可能需要考虑其他方法来协调这些销毁动作。@PreDestroy 是 JSR-250 规范的一部分。要使用它，确保有适当的库依赖（尽管大多数现代 Spring 项目都会有）。@PreDestroy 才会被调用。这意味着，例如，如果我们手动创建一个 bean 的实例（而不是从 Spring 容器中获取），@PreDestroy 方法不会被自动调用。PreDestroyApplication 类的 main 方法中，使用 AnnotationConfigApplicationContext 初始化Spring容器，该方法使用Java注解来配置Spring。我们将 MyConfiguration 作为参数传递，意味着我们希望从这个类开始加载Spring的配置。MyConfiguration 被标记为一个配置类（通过 @Configuration 注解）。其中的 @ComponentScan 注解告诉Spring应该在哪些包里搜索组件。在这个例子中，Spring将会扫描 "com.xcs.spring" 包以及其子包，寻找例如 @Component、@Service、@Repository 和 @Controller 的注解，以此自动地注册bean。com.xcs.spring" 包时，它找到了 MyService 类，这个类被标记为一个Service（通过 @Service 注解）。因此，Spring会为这个类创建一个bean实例。context.close()），所有的单例 beans 将被销毁。在这个过程中，任何带有 @PreDestroy 注解的方法都将被调用。所以，MyService 类中的 preDestroy 方法被执行，打印 "执行@PreDestroy方法"。前置条件
@PreDestroy注解的执行依赖于两个核心接口：MergedBeanDefinitionPostProcessor和DestructionAwareBeanPostProcessor。收集阶段
当Spring处理一个Bean的定义并且这个Bean可能有@PreDestroy注解时，InitDestroyAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法会被调用。
在此方法中，与bean相关的LifecycleMetadata（包括@PreDestroy方法信息）被收集并缓存起来，以便后续使用。
销毁阶段
当 Spring 上下文关闭时（如调用 context.close()），所有的单例 beans 将被销毁。
postProcessBeforeDestruction 方法是 DestructionAwareBeanPostProcessor 接口的一部分，它会被调用来处理每一个需要销毁的 bean。
在这个方法中，再次调用 findLifecycleMetadata 方法从缓存中获取 LifecycleMetadata。
之后，invokeDestroyMethods 方法会遍历所有销毁方法并在目标 bean 上调用它们。
执行是通过查找bean的LifecycleMetadata（在之前的收集阶段中已经构建），然后迭代这些元数据中的方法，并使用反射来调用它们。
实际方法调用
@PreDestroy方法时，会使用LifecycleElement类的invoke方法，该方法再次使用反射来确保方法是可访问的，并实际调用它。此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。