PostConstruct和PreDestroy实现原理

最新推荐文章于 2025-06-11 10:06:33 发布
最新推荐文章于 2025-06-11 10:06:33 发布
阅读量293 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring学习笔记 文章标签： spring java bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40328623/article/details/118657859
本文介绍了Spring框架中PostConstruct和PreDestroy注解的处理方式，它们分别对应于bean的初始化和销毁阶段。关键处理类是CommonAnnotationBeanPostProcessor，它在BeanDefinition合并后进行回调，通过MergedBeanDefinitionPostProcessor和BeanPostProcessor接口来管理bean的生命周期。文章详细阐述了这两个注解的元数据构建和调用时机。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring版本5.2.12.RELEASE
PostConstruct是bean的初始化方法，PreDestroy是Bean销毁的方法，他们都是Java原生的注解 ,处理这两个注解的类为：org.springframework.context.annotation.CommonAnnotationBeanPostProcessor该类是注解驱动的spring应用上下文内建的可以查找的依赖
在这里插入图片描述
实现原理解析：
CommonAnnotationBeanPostProcessor，该类主要是定义初始化的销毁的注解类型，这个类的构造函数中设置了初始化注解类型和销毁的注解类型

	public CommonAnnotationBeanPostProcessor() {
		//设置PostProcessor的优先级
		setOrder(Ordered.LOWEST_PRECEDENCE - 3);
		//设置初始化方法的注解类型
		setInitAnnotationType(PostConstruct.class);
		//设置销毁方法的注解类型
		setDestroyAnnotationType(PreDestroy.class);
		ignoreResourceType("javax.xml.ws.WebServiceContext");
	}

处理这两个注解主要是在CommonAnnotationBeanPostProcessor父类InitDestroyAnnotationBeanPostProcessor，从类的结构图中可以看出，InitDestroyAnnotationBeanPostProcessor是MergedBeanDefinitionPostProcessor实现类，并且MergedBeanDefinitionPostProcessor是个Bean的后置处理器，主要是在BeanDefinition合并后进行回调。

注解的处理

1.处理的入口，BeanDefinition合并后的回调方法

//回调方法
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		LifecycleMetadata metadata = findLifecycleMetadata(beanType);
		metadata.checkConfigMembers(beanDefinition);
	}
  1. 寻找PostConstruct 和PreDestory的元数据信息核心的方法是buildLifecycleMetadata
private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
		if (this.lifecycleMetadataCache == null) {
			// Happens after deserialization, during destruction...
			return buildLifecycleMetadata(clazz);
		}
		// Quick check on the concurrent map first, with minimal locking.
		LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
		if (metadata == null) {
			synchronized (this.lifecycleMetadataCache) {
				metadata = this.lifecycleMetadataCache.get(clazz);
				if (metadata == null) {
					metadata = buildLifecycleMetadata(clazz);
					//按照key为class value为被注解方法的元数据放入缓存
					this.lifecycleMetadataCache.put(clazz, metadata);
				}
				return metadata;
			}
		}
		return metadata;
	}
  1. 构造元数据信息。
	private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
		//判断当前Class中是否有PostConstruct 和PreDestroy注解的定义，存在一个即返回true
		if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
			return this.emptyLifecycleMetadata;
		}
		//从这里可看出PostConstruct和PreDestroy 一个类中可定义多个
		List<LifecycleElement> initMethods = new ArrayList<>();
		List<LifecycleElement> destroyMethods = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<LifecycleElement> currInitMethods = new ArrayList<>();
			final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
			//利用反射遍历 bean的class中所有method 是否存在初始化和销毁的注解
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
					//将方法包装为LifecycleElement
					LifecycleElement element = new LifecycleElement(method);
					currInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
					}
				}
				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);
					}
				}
			});
			
			initMethods.addAll(0, currInitMethods);
			destroyMethods.addAll(currDestroyMethods);
			//检查父类中的PostConstruct和PreDestroy注解信息
			targetClass = targetClass.getSuperclass();
		}// 终结条件-》直到targetClass为Object
		while (targetClass != null && targetClass != Object.class);
		//将所有的PostConstruct和PreDestroy 包装为LifecycleMetadata
		return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
				new LifecycleMetadata(clazz, initMethods, destroyMethods));
	}

4.LifecycleElement 是PostConstruct和PreDestroy 包装类

public LifecycleElement(Method method) {
			//方法的不能有入参
			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());
		}
//通过反射调用被注解的方法
public void invoke(Object target) throws Throwable {
			ReflectionUtils.makeAccessible(this.method);
			this.method.invoke(target, (Object[]) null);
		}

5.LifecycleMetadata 一个类中所有的PostConstruct和PreDestroy 包装类

private class LifecycleMetadata {
		
		private final Class<?> targetClass;
		
		private final Collection<LifecycleElement> initMethods;

		private final Collection<LifecycleElement> destroyMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedInitMethods;

		@Nullable
		private volatile Set<LifecycleElement> checkedDestroyMethods;

		public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
				Collection<LifecycleElement> destroyMethods) {

			this.targetClass = targetClass;
			this.initMethods = initMethods;
			this.destroyMethods = destroyMethods;
		}
		//遍历所有的方法对其去重 被private修饰的所有都会执行，被public修饰的只有子类的会被执行，
		public void checkConfigMembers(RootBeanDefinition beanDefinition) {
			Set<LifecycleElement> checkedInitMethods = new LinkedHashSet<>(this.initMethods.size());
			
			for (LifecycleElement element : this.initMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedInitMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedInitMethod(methodIdentifier);
					checkedInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered init method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			Set<LifecycleElement> checkedDestroyMethods = new LinkedHashSet<>(this.destroyMethods.size());
			for (LifecycleElement element : this.destroyMethods) {
				String methodIdentifier = element.getIdentifier();
				if (!beanDefinition.isExternallyManagedDestroyMethod(methodIdentifier)) {
					beanDefinition.registerExternallyManagedDestroyMethod(methodIdentifier);
					checkedDestroyMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Registered destroy method on class [" + this.targetClass.getName() + "]: " + element);
					}
				}
			}
			this.checkedInitMethods = checkedInitMethods;
			this.checkedDestroyMethods = checkedDestroyMethods;
		}
		public void invokeInitMethods(Object target, String beanName) throws Throwable {
			Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
			Collection<LifecycleElement> initMethodsToIterate =
					(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
			if (!initMethodsToIterate.isEmpty()) {
				for (LifecycleElement element : initMethodsToIterate) {
					if (logger.isTraceEnabled()) {
						logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
					}
					element.invoke(target);
				}
			}
		}

		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) {
					if (logger.isTraceEnabled()) {
						logger.trace("Invoking destroy method on bean '" + beanName + "': " + element.getMethod());
					}
					element.invoke(target);
				}
			}
		}

		public boolean hasDestroyMethods() {
			Collection<LifecycleElement> checkedDestroyMethods = this.checkedDestroyMethods;
			Collection<LifecycleElement> destroyMethodsToUse =
					(checkedDestroyMethods != null ? checkedDestroyMethods : this.destroyMethods);
			return !destroyMethodsToUse.isEmpty();
		}
	}

PostConstruct和PreDestroy 调用时机

1.InitDestroyAnnotationBeanPostProcessor 是MergedBeanDefinitionPostProcessor实现类，MergedBeanDefinitionPostProcessor是BeanPostProcessor的子类，
重点实现了bean生命周期方法postProcessBeforeInitialization

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 获取所有的别PostConstruct和PreDestroy注解的方法的元数据信息，从缓存中获取
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
		//调用被PostConstruct 注解的方法
			metadata.invokeInitMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
		}
		return bean;
	}

2.InitDestroyAnnotationBeanPostProcessor是DestructionAwareBeanPostProcessor的实现类，重点实现了postProcessBeforeDestruction的方法，即bean销毁前的回调（调用原理和PostContruct一样）

public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
			metadata.invokeDestroyMethods(bean, beanName);
		}
		catch (InvocationTargetException ex) {
			String msg = "Destroy method on bean with name '" + beanName + "' threw an exception";
			if (logger.isDebugEnabled()) {
				logger.warn(msg, ex.getTargetException());
			}
			else {
				logger.warn(msg + ": " + ex.getTargetException());
			}
		}
		catch (Throwable ex) {
			logger.warn("Failed to invoke destroy method on bean with name '" + beanName + "'", ex);
		}
	}

该方法在调用IOC容器的close方法后回调

如何正确使用 @PostConstruct 和 @PreDestroy 进行资源管理
张彦峰的博客
05-09 2万+
本文系统介绍了 Spring 中 @PostConstruct 和 @PreDestroy 注解的原理、用法及注意事项，深入分析了其在 Bean 生命周期管理中的作用。通过典型案例解析生命周期注解在继承、作用域、异常处理等场景中的表现，帮助开发者避免常见误区，实现资源的安全初始化与优雅释放。
Bean生命周期回调方法全解：@PostConstruct和@PreDestroy
最新发布
Java大师兄的博客
06-17 748
在Spring开发中，我们经常需要在Bean创建后执行一些初始化操作（如加载配置、连接数据库），或在Bean销毁前释放资源（如关闭连接、保存缓存）。和正是解决这类问题的“生命周期管理神器”。两个注解的核心作用与JSR-250规范背景它们在Bean生命周期中的具体执行位置与Spring其他生命周期方法（如）的对比实际开发中的使用场景与避坑指南本文将按照“概念引入→原理讲解→代码实战→场景总结”的逻辑展开，通过生活故事类比抽象概念，结合代码示例和流程图帮助理解，最后总结最佳实践和常见问题。
SpringBoot @PostConstruct原理用法解析
08-18
主要介绍了SpringBoot @PostConstruct原理用法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring框架中@PostConstruct的实现原理
weixin_30344795的博客
01-22 276
在spring项目经常遇到@PostConstruct注解，首先介绍一下它的用途: 被注解的方法，在对象加载完依赖注入后执行。 此注解是在Java EE5规范中加入的，在Servlet生命周期中有一定作用，它通常都是一些初始化的操作，但初始化可能依赖于注入的其他组件，所以要等依赖全部加载完再执行。与之对应的还有@PreDestroy，在对象消亡之前执行，原理差不多，这里不做过多介绍。 那么首先...
学习笔记086——@PostConstruct注解和InitializingBean接口的使用
code__bee的博客
06-11 533
是 Java EE/Jakarta EE 中的一个注解，用于标记一个方法在依赖注入完成后执行初始化操作。它通常与 Spring 框架一起使用，适用于需要在对象初始化时执行特定逻辑的场景。初始化方法：标注的方法会在以下两个操作完成后被调用：依赖注入（DI）完成：Spring 容器完成对 Bean 的属性注入（如 @Autowired、@Value 等）。Bean 实例化：Bean 对象被创建后。
PostConstruct注解解析
Jarbein的博客（Java军师公众号）
11-01 1603
1、背景 想学习PostConstruct的注解的原因是在spring代码中犯了这样一个错误 @Component public class A{ @Autowired private B b; public static <T> T testB(String test) { b.method(); return test; } } 由于上边的testB方法是一个静态方法，所以可以直接调用A.testB,但是testB里边用到
@PostConstruct注解原理解析
Meiko记录
01-22 1273
定义： @PostContruct注解，在方法上加该注解会在项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法。 从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。 用法： @PostConstruct public void someMethod(){} 或者 public @...
Spring IoC容器与Bean管理24：使用注解方式实现Spring IoC五：元数据注解；（@Primary，@PostConstruct，@PreDestroy，@Scope，@Value）
小枯林的博客
08-17 565
说明： （1）本篇博客的代码，沿用【Spring IoC容器与Bean管理23：使用注解方式实现Spring IoC四：自动装配注解（对象依赖注入）；自动装配注解之【按名称装配注解】（@Resource）的使用；】的s08； （2）本篇博客的核心是@Value注解； （3）和【利用XML方式实现SpringIoC容器】相比，【利用注解方式实现SpringIoC容器】是一个妥协和权衡的结果： 目录 一：元数据注解简介 二：案例演示 1.@Scope注解 2.@PostConstruc...
探秘Spring(2)——PostConstruct注解工作原理解析
qq_20221431的博客
10-09 1138
提示：本文的代码环境为SpringBoot2.3.4 文章目录前言一、PostConstruct是什么？二、可以做什么三、工作原理总结 前言 Spring已成为java开发web应用必会技术栈，本系列文章着重为大家揭秘spring中的技术点，本文重点介绍Bean实例化之后，依靠注解PostConstruct可以做的一些初始化的工作。 一、PostConstruct是什么？ 从注解的全限定名(javax.annotation.PostConstruct)可以看出这个注解是JDK本身自带的注解，JDK中对
Spring启动时的初始化与销毁操作：@PostConstruct & @PreDestroy注解详解
总结来说，本文详细讲解了如何利用Spring的`@PostConstruct`和`@PreDestroy`注解以及XML配置文件中的`init-method`和`destroy-method`属性来管理bean的初始化和销毁过程，以及通过接口实现更高级别的定制化控制。...
Spring @Autowird注解和@Resouce注解源码分析
持之以恒
07-28 621
从使用上来看@Autowird和@Resource注解的区别 两个注解都可用于属性或者方法上的注入；@Autowired是默认按照类型装配， @Resource默认是按照名称装配 从提供来源看： @Autowired是由Spring提供 @Resource是有java提供，在包javax.annotation下 从spring处理源看： @Autowired是由AutowiredAnnotationBeanPostProcessor后处理器进行处理 @Resource是由CommonAnnotat
@PostConstruct 和 @PreDestroy
Isnotsuitable的专栏
02-29 4859
@PostConstruct ,@PreDestroy Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法，也可以通过 元素的 init-method/destroy-method 属性
@PostConstruct方法的使用以及原理
mengtianqq的博客
12-28 1207
往往我们在项目启动时需要加载某个方法的时候， 可以使用@Component+@PostConstruct方法将一个方法完成初始化操作， @PostConstruct注解的方法会将在依赖注入完成之后被自动调用。该注解在整个Bean初始化中执行的顺序： @Constructor（构造方法）->@Autowired（依赖注入）->@PostConstruct（注解的方法） @PostConstruct public void init() { //可以使用业务逻辑 } ...
java postconstruct_spring框架中@PostConstruct的实现原理
weixin_39763640的博客
02-16 252
在spring项目经常遇到@PostConstruct注解，首先介绍一下它的用途: 被注解的方法，在对象加载完依赖注入后执行。此注解是在Java EE5规范中加入的，在Servlet生命周期中有一定作用，它通常都是一些初始化的操作，但初始化可能依赖于注入的其他组件，所以要等依赖全部加载完再执行。与之对应的还有@PreDestroy，在对象消亡之前执行，原理差不多，这里不做过多介绍。那么首先看下源码...
@PostConstruct
weixin_42267704的博客
06-13 195
springboot项目如果想实现启动后自动运行某个方法，慎用@PostConstruct注解，最好老老实实实现ApplicationRunner，然后重写run方法，不然会造成某些bean还未注入spring，方法却已运行，造成某些资源无法正常被调用。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值