Spring 源码学习（七）——注解后处理器-2

已于 2025-02-02 16:31:00 修改
阅读量941 收藏 28
点赞数 19
文章标签： spring 学习 java
于 2025-01-24 23:01:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_63445802/article/details/145347697
版权

五 InitDestroyAnnotationBeanPostProcessor 类

1 属性

        InitDestroyAnnotationBeanPostProcessor 类用于处理初始化与销毁注解；其中第一个属性为用于标识初始化方法与销毁方法注解类型的 initAnnotationType 与 destroyAnnotationType 属性、还有一个用于标识执行顺序的 order 属性，默认为最大值、用于缓存生命周期元数据的 lifecycleMetadataCache 及一个标识空生命周期元数据对象的 emptyLifecycleMetadata 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {

	private final transient LifecycleMetadata emptyLifecycleMetadata =
			new LifecycleMetadata(Object.class, Collections.emptyList(), Collections.emptyList()) {
				@Override
				public void checkConfigMembers(RootBeanDefinition beanDefinition) {
				}
				@Override
				public void invokeInitMethods(Object target, String beanName) {
				}
				@Override
				public void invokeDestroyMethods(Object target, String beanName) {
				}
				@Override
				public boolean hasDestroyMethods() {
					return false;
				}
			};


	protected transient Log logger = LogFactory.getLog(getClass());

	@Nullable
	private Class<? extends Annotation> initAnnotationType;

	@Nullable
	private Class<? extends Annotation> destroyAnnotationType;

	private int order = Ordered.LOWEST_PRECEDENCE;

	@Nullable
	private final transient Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);

	public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
		this.initAnnotationType = initAnnotationType;
	}

	public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {
		this.destroyAnnotationType = destroyAnnotationType;
	}

	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}
}

2 类方法

2.1 postProcessMergedBeanDefinition 方法

         postProcessMergedBeanDefinition 方法在通过 findLifecycleMetadata 方法创建 LifecycleMetadata 对象后并使用 beanDefinition 执行其的 checkConfigMembers 方法向对象注册表中注册初始化与销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		LifecycleMetadata metadata = findLifecycleMetadata(beanType);
		metadata.checkConfigMembers(beanDefinition);
	}
}

        findLifecycleMetadata 方法在 lifecycleMetadataCache 缓存为 null 时直接执行 buildLifecycleMetadata 方法创建 LifecycleMetadata 对象并返回，否则首先尝试从该缓存中获取 clazz 对应的元数据，获取到时直接返回缓存对象，否则 buildLifecycleMetadata 方法创建 LifecycleMetadata 对象并保存到 lifecycleMetadataCache 缓存中同时返回；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	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;
	}
}

         buildLifecycleMetadata 方法在 clazz 参数没有使用 initAnnotationType 与 destroyAnnotationType 注解进行修饰时直接返回 emptyLifecycleMetadata 空生命周期元数据，然后寻找 clazz 参数及其所有父类中使用 initAnnotationType 与 destroyAnnotationType 注解修饰方法并使用 LifecycleElement 类对其进行封装，最后在查询完毕后，使用 clazz 、查询到的初始化方法与销毁方法封装对象数组创建 LifecycleMetadata 对象并返回；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
			return this.emptyLifecycleMetadata;
		}

		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<>();

			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
					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);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
				new LifecycleMetadata(clazz, initMethods, destroyMethods));
	}
}

2.2 postProcessBeforeInitialization 方法

         postProcessBeforeInitialization 方法首先通过 findLifecycleMetadata 查询 bean 参数对应的生命周期元数据并调用其 invokeInitMethods 方法执行初始化方法并在执行完成后返回 bean 参数；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
		try {
			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.3 postProcessAfterInitialization 方法

         postProcessAfterInitialization 方法不执行任何逻辑直接返回 bean 参数；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}
}

2.4 postProcessBeforeDestruction 方法

         postProcessBeforeDestruction 方法首先通过 findLifecycleMetadata 查询 bean 参数对应的生命周期元数据并调用其 invokeDestroyMethods 方法执行销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	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);
		}
	}
}

2.5 requiresDestruction 方法

         requiresDestruction 方法获取 bean 参数对应的生命周期元数据并然后其使用拥有销毁方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	@Override
	public boolean requiresDestruction(Object bean) {
		return findLifecycleMetadata(bean.getClass()).hasDestroyMethods();
	}
}

3 LifecycleElement 内部类

3.1 属性及构造方法

3.1.1 类属性

         LifecycleElement 类用于封装方法对象，其拥有保存封装 Method 方法对象的 method 属性与方法名标识的 identifier 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		private final Method method;

		private final String identifier;

		public Method getMethod() {
			return this.method;
		}

		public String getIdentifier() {
			return this.identifier;
		}
	}
}
3.1.2 构造方法

         LifecycleElement 类只有一个构造方法，其只有一个 Method 类型参数，在创建过程中首先对 method 参数的参数个数进行空验证，即不为空直接报错；验证通过后首先将 method 属性初始化为 method 参数值，随后在若 mothod 为私有方法时将 identifer 属性初始化为全限定类名 + 方法名，否则直接初始化为方法名；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		public LifecycleElement(Method method) {
			if (method.getParameterCount() != 0) {
				throw new IllegalStateException("Lifecycle method annotation requires a no-arg method: " + method);
			}
			this.method = method;
			this.identifier = (Modifier.isPrivate(method.getModifiers()) ?
					ClassUtils.getQualifiedMethodName(method) : method.getName());
		}
	}
}

3.2 invoke 方法

         invoke 方法直接执行 method 属性的 invoke 方法；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private static class LifecycleElement {
		public void invoke(Object target) throws Throwable {
			ReflectionUtils.makeAccessible(this.method);
			this.method.invoke(target, (Object[]) null);
		}
	}
}

4 LifecycleMetadata 内部类

4.1 属性及构造方法

4.1.1 类属性

        LifecycleMetadata 类用于封装类以向外提供对生命周期元数据的处理，其中 targerClass 属性保存的时封装的 Class 类型对象、initMethods 与 checkedInitMethods 属性分别保存所有初始化方法元数据封装集合与通过验证后的初始化方法元数据封装集合及保存所有销毁方法元数据封装集合与通过验证后的销毁方法元数据封装集合的 destroyMethods 与 checkedDestroyMethods 属性；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	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;
	}
}
4.1.2 构造方法

        LifecycleMetadata 类只有一个分别将 targetClass、initMethods 与 destroyMethods 属性初始化为对应的入参属性值；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
				Collection<LifecycleElement> destroyMethods) {

			this.targetClass = targetClass;
			this.initMethods = initMethods;
			this.destroyMethods = destroyMethods;
		}
	}
}

4.2 类方法

4.2.1 checkConfigMembers 方法

        checkConfigMembers 方法分别将 beanDefinition 中未注册 initMethods 与 destroyMethods 属性中的元素注册到该对象注册表并保存到 checkedInitMethods 与 checkedDestroyMethods 属性中；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		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;
		}
	}
}
4.2.2 invokeInitMethods 方法

        invokeInitMethods 方法在 checkedInitMethods 属性不为空依次执行所有元素，否则依次执行 initMethods 属性中的所有元素；

public class InitDestroyAnnotationBeanPostProcessor
		implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable {
	private class LifecycleMetadata {
		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
最低0.47元/天 解锁文章
Spring 源码学习（七）——注解后处理器-1
weixin_63445802的博客
12-10 855
通过之前对注解式配置的解析（）可以发现其使用 AnnotationConfigUtils 类的 registerAnnotationConfigProcessors 静态方法对象注解后处理器对象进行注册；
Spring 源码学习（三）—— 注解式配置解析
最新发布
weixin_63445802的博客
10-30 908
AbstractTypeHierarchyTraversingFilter 抽象类只有两个使用 final 修饰的属性，分别为匹配时是否考虑匹配父类或接口的 considerInherited 与 considerInterfaces 属性；AbstractClassTestingTypeFilter 抽象类实现了 match 方法，其直接获取 metadataReader 参数的 ClassMetadata 原始参数并使用该对象执行单一参数的 match 方法；
java：@PostConstruct注解使用
a232884c的博客
01-25 7484
java：@PostConstruct注解使用 1 使用条件 1.1 方法是非静态方法 1.2 注解修饰的方法，不可以具有参数 否则抛错： Lifecycle method annotation requires a no-arg method 1.3 注解修饰的方法，返回值是void 实际上，可以有返回值，springboot启动没有抛错，但一般仅用于初始化bean，添加些缓存数据用，故而一般不需要返回值： @PostConstruct public String Yhinit(){ log.er
Java注解@PostConstruct使用及相关原理分析
kolloge的博客
11-04 4007
Java注解PostConstruct原理及相关问题分析，Spring容器中同类使用多PostConstruct顺序不固定问题等
PostConstruct注解
yuyeqianhen的博客
05-06 1216
注意：PostConstruct注解不可以有参数的，否则就会报错：java.lang.IllegalStateException: Lifecycle method annotation requires a no-arg method
@PostConstruct注解只能用在无参构造方法上
qq_34412985的博客
04-04 712
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'esUtil' defined in file [D:\code\xxx\xxx\target\classes\com\xxx\elasticsearch\util\EsUtil.class]: Pos...
Spring源码 - @Resource、@PostConstruct、@PreDestroy原理分析（CommonAnnotationBeanPostProcessor - 下）
it_lihongmin的博客
12-24 453
目录 一、注解LifecycleMetadata的生命周期 1、findLifecycleMetadata（递归获取生命周期注解添加到容器） 2、invokeInitMethods 3、invokeDestroyMethods 二、注解InjectionMetadata的生命周期 1、findResourceMetadata（递归获取@Resource注解添加到容器） 2、check...
Spring注解09——BeanPostProcessor后置处理器深度剖析
大黄奔跑
08-15 532
该系列文章主要学习 雷丰阳老师的《Spring注解驱动》课程总结。 原课程地址：课程地址 包括了自己阅读其他书籍《Spring揭秘》《Spring Boot 实战》等课程。 该系列文档会不断的完善，欢迎大家留言及提意见。 文章目录1. 写在之前2. BeanPostProcessor 是什么3. xxxBeanPostProcessor 源码分析4. Spring框架用该接口干嘛呢？总结 1. 写在之前 本篇会有一些源码的分析，如果暂时觉得没有用处，可以跳过该章节。 为什么要有 BeanPostProc.
Spring源码——Spring MVC
等一杯咖啡的博客
11-22 1766
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第十一章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework Spring框架提供了构建Web应用程序的全功能MVC模...
Spring使用@PostConstruct注解完成子类注入父类私有变量
屎大小仙女的博客
08-10 1万+
原博在此：http://www.cnblogs.com/walson/p/3897661.html 讲了三个使用注解在子类中替换父类私有变量的方法，其中@PostConstruct方法有误。 注解使用方式应为如下： 父类： public class BaseServiceImpl { private BaseDao baseDao; public BaseDao getB
java ioc依赖注入,Spring bean的实例化和IOC依赖注入详解
weixin_34774527的博客
03-11 417
前言我们知道，IOC是Spring的核心。它来负责控制对象的生命周期和对象间的关系。举个例子，我们如何来找对象的呢？常见的情况是，在路上要到处去看哪个MM既漂亮身材又好，符合我们的口味。就打听她们的电话号码，制造关联想办法认识她们，然后...这里省略N步，最后谈恋爱结婚。IOC在这里就像婚介所，里面有很多适婚男女的资料，如果你有需求，直接告诉它你需要个什么样的女朋友就好了。它会给我们提供一个MM，...
springMVC详解以及注解说明
zxw882011_98的专栏
12-26 995
基于注释（Annotation）的配置有越来越流行的趋势，Spring 2.5 顺应这种趋势，提供了完全基于注释配置 Bean、装配 Bean 的功能，您可以使用基于注释的 Spring IoC 替换原来基于 XML 的配置。本文通过实例详细讲述了 Spring 2.5 基于注释 IoC 功能的使用。 概述 注释配置相对于 XML 配置具有很多的优势： · 它可以充分利用 Java 的反射机
@PostConstruct
suixinsuoyu12519的专栏
11-07 3355
1、从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。写法有如下两种方式：   @PostConstruct public void someMethod(){} 或者 public @PostConstruct void someMethod()...
@Resource annotation requires a single-arg method
ClearLoveQ的博客
01-26 3854
测试时出现这个报错： @Resource的位置写错了，或者多写了一个注解
nested exception is java.lang.IllegalStateException: @Resource annotation requires a single-arg meth
朋友从陌生人开始的博客
05-13 5371
springMVC问题：nested exception is java.lang.IllegalStateException: @Resource annotation requires a single-arg method: public java.lang.String com.hxjf.xingsanban.TestFrame.test2() 问题原因：多写了一个@resource
IDEA启动报错：Lombok Requires Annotation Processing ... 已解决
热门推荐
Java Punk
05-05 2万+
【File】-->【Settings】-->【Build】-->【Compiler】-->【Annotation Processing】--> 勾选“enable Annotation Processing”
java.lang.IllegalStateException: @Resource annotation requires a single-arg method
wxg1453149997的专栏
05-09 7180
错误发生场景： 删除一个类里面的成员变量却忘记了删除@Resource，导致此注解和一个有两个参数的方法有了联系 解决方案： @Resource应该放在成员变量上或者只有一个参数的方法上
深入理解Spring：IOC容器的源码解析
通过深入理解Spring源码，开发者可以更好地利用这些特性，优化应用性能，以及进行更高效的故障排查。 Spring的源码分析有助于开发者深入了解其实现原理，这对于优化代码、解决复杂问题以及定制化扩展Spring功能非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值