公共字段自动填充

什么是公共字段自动填充呢，那什么又是公共字段呢，所谓的公共字段就是共用同一个数据库字段的变量，比如数据库中有create_time，create_user，update_time和update_user的字段，进行update（即修改信息）和insert（即添加或插入信息）操作时，update操作时需要改变这4个字段，而insert则只需要改变create_time，create_user这两个字段，（更新或插入信息是）后端设置值时是不是时常需要重复使用这些字段，这就会很麻烦，这时候我们就需要写一个注解和类帮我们把这些字段自动填充（即自动识别并补充该字段）：

AOP

实现代码前，我们需要知道Spring中AOP（面向切面编程），简单的说，就像给核心流程（如“泡咖啡”）自动添加“插件”：在方法执行的特定节点（如调用前、后），动态插入通用操作（如日志、权限检查），而无需修改原代码，将分散的横切逻辑（如监控、事务）抽离为独立模块，实现解耦和复用。

举个例子

假设你每天都要「泡咖啡」——核心流程是烧水、倒咖啡粉、冲泡，但每次泡咖啡前后你总会自动执行一些重复动作：泡之前检查咖啡豆库存（前置通知），泡之后清洗杯子（后置通知）。Spring AOP 就像给你的生活添加了一个“智能管家”，它会自动在“泡咖啡”这个切入点前后插入检查库存和清洗杯子的操作，而无需你手动写进流程，既保持核心步骤清晰，又能复用通用逻辑（比如泡茶时也能复用检查库存）。

实现公共字段自动填充（示例）

首先创建一个注解（用于识别哪些方法需要处理 ），即切点

package com.sky.annotation;

import com.sky.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();
}

接下来创建类，作为实现的操作，即切面

package com.sky.aspect;

import com.sky.annotation.AutoFill;
import com.sky.constant.AutoFillConstant;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
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.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

/**
 * 自定义切面，实现公共字段自动填充逻辑
 */
@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();//这个获取id的方法就是我们之前说的ThreadLocal，如果不了解，可以去我主页看看

        //根据当前不同的操作类型，为对应的属性通过反射来赋值
        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();
            }
        }
        
    }
}

然后为需要进行操作的方法添加注解，让它（方法）被识别到

最后我们就可以减少很多代码冗余了