Spring开发中自定义注解的使用

怼烎@ 2024-03-17 21:22 79阅读 0赞

**在Java项目中，可以自定义注解，方便进行某些处理操作，提供开发效率。**

比如，在进行实体类的crud操作时，一般都有create\_time, createUser, updateTime, updateUser这几个字段，而且不是核心业务代码,这时可以引入注解简化开发和提高效率。比如下面这段代码：

//实体类的新增操作
    public void save(CategoryDTO categoryDTO) {
        
           //....................................
            //设置创建时间、修改时间、创建人、修改人
            category.setCreateTime(LocalDateTime.now());
            category.setUpdateTime(LocalDateTime.now());
            category.setCreateUser(BaseContext.getCurrentId());
            category.setUpdateUser(BaseContext.getCurrentId());
            categoryMapper.insert(category);
      }

如果都按照上述的操作方式来处理这些公共字段, 需要在每一个业务方法中进行操作, 编码相对冗余、繁琐，那能不能对于这些公共字段在某个地方统一处理，来简化开发呢?

以下以自定义注解AutoFill为例，使用**AOP切面编程**，实现功能增强，来完成公共字段自动填充功能。 **说明如何自定义注解，和使用注解**

> **实现步骤：**
> 
> 1.  自定义注解 AutoFill，用于标识需要进行公共字段自动填充的方法
> 2.  自定义切面类 AutoFillAspect，统一拦截加入了 AutoFill 注解的方法，通过反射为公共字段赋值
> 3.  在 Mapper 的方法上加入 AutoFill 注解

#### 1. 引入maven依赖 ####

<dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.9.4</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.4</version>
            </dependency>

#### 2. 自定义注解 ####

package com.zsx.annotation;
    
    import com.zsx.enumeration.OperationType;
    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();
    }

枚举类OperationType

package com.zsx.enumeration;
    
    /**
     * 数据库操作类型
     */
    public enum OperationType {
        
    
        /**
         * 更新操作
         */
        UPDATE,
    
        /**
         * 插入操作
         */
        INSERT
    }

#### 3. 自定义切面 ####

package com.zsx.aspect;
    
    import com.zsx.annotation.AutoFill;
    import com.zsx.constant.AutoFillConstant;
    import com.zsx.context.BaseContext;
    import com.zsx.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 {
        
    
        /**
         * 切入点
         */
        @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
        public void autoFillPointCut(){
        }
    
        /**
         * 前置通知，在通知中进行公共字段的赋值
         */
        @Before("autoFillPointCut()")
        public void autoFill(JoinPoint joinPoint){
        
            log.info("开始进行公共字段自动填充...");
    
            //获取到当前被拦截的方法上的数据库操作类型
            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){
        
                //为4个公共字段赋值
                try {
        
                    Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                    Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                    Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                    Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
    
                    //通过反射为对象属性赋值
                    setCreateTime.invoke(entity,now);
                    setCreateUser.invoke(entity,currentId);
                    setUpdateTime.invoke(entity,now);
                    setUpdateUser.invoke(entity,currentId);
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }else if(operationType == OperationType.UPDATE){
        
                //为2个公共字段赋值
                try {
        
                    Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                    Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);
    
                    //通过反射为对象属性赋值
                    setUpdateTime.invoke(entity,now);
                    setUpdateUser.invoke(entity,currentId);
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

AutoFillConstant 常量类

package com.zsx.reggie.constant;
    
    /**
     * 公共字段自动填充相关常量
     */
    public class AutoFillConstant {
        
    
        /**
         * 实体类中的方法名称
         */
        public static final String SET_CREATE_TIME = "setCreateTime";
    
        public static final String SET_CREATE_USER = "setCreateUser";
    
        public static final String SET_UPDATE_TIME = "setUpdateTime";
    
        public static final String SET_UPDATE_USER = "setUpdateUser";
    
    }

#### 4. 使用注解 ####

**在Mapper接口的方法上加入 AutoFill 注解**

package com.sky.mapper;
    
    @Mapper
    public interface CategoryMapper {
        
        /**
         * 插入数据
         * @param category
         */
        @Insert("insert into category(type, name, sort, status, create_time, update_time, create_user, update_user)" +
                " VALUES" +
                " (#{type}, #{name}, #{sort}, #{status}, #{createTime}, #{updateTime}, #{createUser}, #{updateUser})")
        @AutoFill(value = OperationType.INSERT)
        void insert(Category category);
        
        /**
         * 根据id修改分类
         * @param category
         */
        @AutoFill(value = OperationType.UPDATE)
        void update(Category category);
    }

完成，这样在每次插入和更新操作的时候，就可以自动设置更新时间和更新人id。  
（不过要注意，这里的sql语句中的这几个字段还是不能缺少）