自定义Java注解及其应用

上一篇博客：Java注解

 写在前面：大家好！我是晴空๓。如果博客中有不足或者的错误的地方欢迎在评论区或者私信我指正，感谢大家的不吝赐教。我的唯一博客更新地址是：https://ac-fun.blog.csdn.net/。非常感谢大家的支持。一起加油，冲鸭！
 用知识改变命运，用知识成就未来！加油 (ง •̀o•́)ง (ง •̀o•́)ง

前言

 在上一篇 Java注解 中主要写了注解的一些示例以及注解的组成，本篇主要介绍一下如何自定义注解以及如何将自定义的注解结合反射进行使用。

自定义注解

 通过上一篇博客Java注解中 注解的组成 部分就可以知道我们如何自定义注解了。但是自定义注解还有一些需要注意的点，主要如下：

成员变量

 Annotation 的成员变量以无参数方法形式来声明，方法名和返回值定义了该成员变量的名字和类型。类型只能是八种基本数据类型（byte、short、int、long、float、double、char、boolean）、String类型、Class类型、enum类型、Annotation类型以及以上所有类型的数组

初始值

 可以在定义成员变量时为其指定初始值，指定成员变量的初始值可以用 default关键字

public @interface MyAnnotation {int value() default 10;
}

注解的元注解使用

 合理的使用注解的元注解，通过元注解指定注解的保留策略以及注解可以应用的目标位置，详见上一篇博客Java注解。

注解与反射的关系

 只有当注解的保留策略为 @Retention(RetentionPolicy.RUNTIME) 时，才能在运行时通过反射获取注解信息。

 反射操作（如获取类的字段、方法，调用方法等）比直接的Java代码调用要慢很多。每次通过反射获取注解信息或者执行注解相关的操作，都需要进行额外的类型检查、权限验证等步骤。 例如，频繁地使用反射来检查一个类的所有方法上是否有某个注解，并根据注解来执行不同的逻辑，在高并发或者对性能要求极高的场景下，可能会成为性能瓶颈。

 如果注解的处理逻辑对性能影响较大，可以考虑缓存反射操作的结果。或者在系统启动时，预先加载并处理好所有需要通过注解进行操作的类和方法信息。

自定义注解结合反射示例

 之前看尚硅谷的苍穹外卖中就有一个合适的例子，这里简单写一下并附上当时的笔记。假设我们的项目中有很多张表都具有相同的创建时间、修改时间、创建人id、修改人id这几个公共字段，我们希望将这些初始化代码统一放在一个地方进行处理以减少冗余代码同时也可以更方便的维护。这就需要我们使用注解进行标注什么时候应该调用公共的初始化方法进行相关的初始化操作，同时也需要利用反射为公共字段赋值。以下是详细的实现步骤。

自定义AutoFill注解

 首先定义一个用于标识什么时候调用相关初始化代码的注解 AutoFill，该注解有一个字段表示是插入操作还是修改操作，我们需要这个标识进行判断初始化的时候是只初始化创建时间和创建人id，还是都需要初始化。

数据库操作类型枚举类

/*** 数据库操作类型枚举*/
public enum OperationType {/*** 更新操作*/UPDATE,/*** 插入操作*/INSERT}

AutoFill注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {// 数据库操作类型：UPDATE-更新 INSERT-插入OperationType value();
}

自定义切面类

 定义好注解之后需要使用反射获取注解的信息并进行相应的处理，使用切面类进行拦截。

import com.sky.annotation.AutoFill;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;import java.lang.reflect.Method;
import java.time.LocalDateTime;/*** 自定义切面实现公共处理逻辑*/
@Aspect
@Component
@Slf4j
public class AutoFillAspect {/*** 定义切入点* 1. execution:最长用的 PCD（切入点标识符），用来匹配特定方法的执行，具体参数如下：*      execution([修饰符] <返回类型> [全限定类名.]<方法>(<参数>) [异常])*      这其中每一部分都可以使用 * 通配符， []表示选输 <>表示必输*      类名中使用 .* 表示包中的所有类， ..* 表示当前包与子包中的所有类*      参数主要分为以下几种情况：*          - () 表示方法五参数*          - (..) 表示有任意个参数*          - (*) 表示有一个任意类型的参数*          - (String) 表示有一个 String 类型的参数*          - (String, String) 表示有两个 String 类型的参数** 2. 如果类上面带了注解，也可以用以下 PCD*      - @target 指定的目标对象带有特定类型的注解*      - @args 传入的方法参数带有特定类型的注解*      - @annotation 拦截的方法上带有特定类型的注解*/@Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")public void autoFillPointCut(){}/*** 前置通知* @param joinPoint 连接点*      JoinPoint 表示程序执行过程中的一个连接点，通常是方法的调用。*      JoinPoint 提供了关于当前连接点的详细信息，这些信息可以用于在通知（Advice）中进行各种操作，*                  如日志记录、参数检查、性能监控等。**/@Before("autoFillPointCut()")public void autoFill(JoinPoint joinPoint) {log.info("开始进行公共字段自动填充[{}]", joinPoint);// 获取当前被拦截方法上@AutoFill()中的数据库操作类型/** 获取方法的签名对象*       getSignature() 是 JoinPoint 接口中的一个方法，用于获取当前连接点的签名。*    签名包含了方法的名称、参数类型和返回类型等信息。Signature 接口提供了多种方法，可以用来获取这些详细信息*    joinPoint.getSignature() 返回的 Signature 对象可以强制转换为几种类型，具体取决于当前连接点的类型，在Spring AOP 中*    最常见的类型是 MethodSignature, MethodSignature 是 Signature 的一个子接口，用于表示方法执行的连接点。*    它提供了更多关于方法的详细信息，如参数名称、参数类型、返回类型等。除了该类型还有 ConstructorSignature（构造器连接点）*    和 FieldSignature（字段访问连接点）*      MethodSignature 常用方法如下：*          - String getName()：返回方法的名称。*          - Class<?> getDeclaringType()：返回声明该方法的类。*          - Class<?> getReturnType()：返回方法的返回类型。*          - Class<?>[].getParameterTypes()：返回方法的参数类型数组。*          - String[].getParameterNames()：返回方法的参数名称数组。*          - Method getMethod()：返回 java.lang.reflect.Method 对象。**/MethodSignature signature = (MethodSignature) joinPoint.getSignature();// 获取方法上的注解对象AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);// 获取数据库操作类型OperationType operationType = autoFill.value();// 获取被拦截方法的参数（约定实体为第一个参数）/*joinPoint.getArgs() 方法是 JoinPoint 接口中的一个方法，用于获取当前连接点（通常是方法调用）的参数数组。这个方法返回一个 Object[] 类型的数组，其中每个元素对应方法调用的一个参数。*/Object[] args = joinPoint.getArgs();if (args == null || args.length == 0) {return;}// 获取方法的第一个参数及实体对象Object entity = args[0];// 为参数中的对象的公共属性进行赋值LocalDateTime now = LocalDateTime.now();Long currentId = BaseContext.getCurrentId();if (operationType == OperationType.INSERT) {try {// 通过反射获取实体类中的相关set方法// 通过反射获取指定名称和参数类型的已声明方法Method setCreatTime = entity.getClass().getDeclaredMethod("setCreatTime", LocalDateTime.class);Method setCreateUser = entity.getClass().getDeclaredMethod("setCreateUser", Long.class);Method setUpdateTime = entity.getClass().getDeclaredMethod("setUpdateTime", LocalDateTime.class);Method setUpdateUser = entity.getClass().getDeclaredMethod("setUpdateUser", Long.class);// 通过反射为对象属性赋值setCreatTime.invoke(entity, now);setCreateUser.invoke(entity, currentId);setUpdateTime.invoke(entity, now);setUpdateUser.invoke(entity, currentId);} catch (Exception e) {throw new RuntimeException(e);}} else if (operationType == OperationType.UPDATE) {try {// 通过反射获取实体类中的相关set方法// 通过反射获取指定名称和参数类型的已声明方法Method setUpdateTime = entity.getClass().getDeclaredMethod("setUpdateTime", LocalDateTime.class);Method setUpdateUser = entity.getClass().getDeclaredMethod("setUpdateUser", Long.class);// 通过反射为对象属性赋值setUpdateTime.invoke(entity, now);setUpdateUser.invoke(entity, currentId);} catch (Exception e) {throw new RuntimeException(e);}}}}

 可以通过打断点的方式看一下 joinPoint 连接点 里面的具体内容都是什么。

代码优化

 上面是之前老师写的代码以及自己的学习笔记，其实这个代码可以再优化一下。优化的思路主要有两个方面一个是对性能方面的优化这个是主要的，另一点是代码优化将重复的代码封装一下并将公共逻辑拆分出来以便更好的维护。

 性能优化主要在于反射调用可能会对性能产生一定影响，特别是在方法调用频繁的情况下。我们可以使用缓存来存储方法对象，每次调用时都使用反射获取相关信息，而是在缓存中进行查找。这里用一个 Map<String, Method> 来作为缓存池，并将其初始化为一个 ConcurrentHashMap 实例。

 使用 ConcurrentHashMap 的主要原因是它提供了线程安全的哈希表实现，适用于多线程环境。在多线程应用中，多个线程可能会同时访问和修改哈希表，如果没有适当的同步机制，可能会导致数据不一致、并发修改异常等问题。ConcurrentHashMap 通过内部的锁分段机制来确保线程安全，同时提供了较高的并发性能。HashMap 不是线程安全的，多个线程同时写入时可能会导致数据不一致。而 Hashtable 虽然线程安全，但它是通过 synchronized 方法实现的，这会导致整个表在每次操作时都被锁定，性能较差。

优化之后的完整代码：

import com.sky.annotation.AutoFill;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;@Aspect
@Component
@Slf4j
public class AutoFillAspectPlus {/*** 缓存方法对象*/private final Map<String, Method> methodCache = new ConcurrentHashMap<>();@Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")public void autoFillPointCut(){}@Before("autoFillPointCut()")public void autoFill(JoinPoint joinPoint) {log.info("开始进行公共字段自动填充Plus版[{}]", joinPoint.toShortString());MethodSignature signature = (MethodSignature) joinPoint.getSignature();AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);OperationType operationType = autoFill.value();Object[] args = joinPoint.getArgs();if (args == null || args.length == 0) {return;}Object entity = args[0];LocalDateTime now = LocalDateTime.now();Long currentId = BaseContext.getCurrentId();if (operationType == OperationType.INSERT) {setFieldValue(entity, "setCreateTime", now);setFieldValue(entity, "setCreateUser", currentId);setFieldValue(entity, "setUpdateTime", now);setFieldValue(entity, "setUpdateUser", currentId);log.info("初始化完毕[{}]", entity);} else if (operationType == OperationType.UPDATE) {setFieldValue(entity, "setUpdateTime", now);setFieldValue(entity, "setUpdateUser", currentId);log.info("初始化完毕[{}]", entity);}}/*** 设置实体对象中某个字段的值* @param entity 实体对象* @param methodName 字段名称* @param value 字段的值*/private void setFieldValue(Object entity, String methodName, Object value) {try {Method method = getMethod(entity, methodName, value.getClass());log.info("获取到method为[{}]", method.getName());method.invoke(entity, value);} catch (Exception e) {log.error("初始化字段异常: [{}]", methodName, e);throw new RuntimeException(e);}}/*** 查找指定名称和参数类型的方法* @param entity 实体* @param methodName set方法* @param parameterType 参数类型* @return 相关set方法*/private Method getMethod(Object entity, String methodName, Class<?> parameterType) {// 获得方法的名称,使用 类名.方法名 作为keyString key = entity.getClass().getName() + "." + methodName;log.info("获取当前key[{}]的值", key);/*computeIfAbsent 方法是 ConcurrentHashMap 的一个方法，它接受一个键和一个函数。如果缓存中已经存在这个键，它会返回缓存中的值；如果不存在，它会执行提供的函数，将结果存储在缓存中，并返回这个结果。确保方法对象的查找和缓存操作是线程安全的。*/return methodCache.computeIfAbsent(key, k -> {try {return entity.getClass().getDeclaredMethod(methodName, parameterType);} catch (NoSuchMethodException e) {log.error("方法未找到: [{}]", methodName, e);throw new RuntimeException(e);}});}}