基于 AOP + 反射实现公共字段自动填充

在 Java 项目的数据库操作中，我们总会遇到这样的重复场景：新增数据时要手动设置createTime、createUser、updateTime、updateUser，修改数据时又要重复设置updateTime、updateUser。这些机械的代码遍布各个 Service 层，不仅让代码臃肿冗余，还容易出现漏写、错写的问题。

而在实际项目中，我们可以利用AOP（面向切面编程）+反射技术，封装一套公共字段自动填充方案，让这些重复性字段的赋值工作由程序自动完成。开发者只需简单添加注解，无需再写任何硬编码赋值代码，极大提升开发效率和代码整洁度。今天就从核心设计、实现原理、组件配合三个维度，详解这套优雅的解决方案。

一、核心设计思想：面向切面的无侵入式增强

公共字段自动填充的核心设计思想，是将公共字段的赋值逻辑从业务代码中抽离出来，通过 AOP 在数据库操作方法执行前统一增强，具体实现依托四个核心组件的协同工作：

1. 枚举类：定义数据库操作类型，区分新增和修改的不同填充规则；
2. 自定义注解：作为 “标签” 标记需要自动填充的 Mapper 方法；
3. 切面类：核心执行者，拦截标记注解的方法，通过反射完成字段自动赋值；
4. 常量类：统一管理反射所需的方法名，避免硬编码，提升代码可维护性。

整个方案对原有业务代码0 侵入，既不修改 Mapper 接口的定义，也不改变 Service 层的调用方式，开发者只需在 Mapper 方法上添加注解，即可实现自动填充，符合 “开闭原则”。

二、四大核心组件：各司其职，协同工作

公共字段自动填充的实现依赖四个核心类的配合，它们各自承担不同的职责，形成一套完整的自动填充链路。以下是各组件的详细设计和代码实现。

1. 核心枚举：OperationType—— 定义操作类型，区分填充规则

首先定义一个枚举类，明确数据库的两种核心操作类型：INSERT（新增）和UPDATE（修改），因为这两种操作对应的自动填充字段不同：

• 新增操作：需要填充createTime、createUser、updateTime、updateUser四个字段；
• 修改操作：仅需要填充updateTime、updateUser两个字段。

枚举类代码简洁且语义明确，作为后续切面判断填充规则的依据：

package com.sky.enumeration; /** * 数据库操作类型枚举 */ public enum OperationType { /** * 新增操作 */ INSERT, /** * 修改操作 */ UPDATE }

2. 自定义注解：@AutoFill—— 作为 “标签”，标记需要自动填充的方法

接下来定义一个自定义注解@AutoFill，该注解仅作用于方法，且在运行时有效，用于标记 Mapper 接口中需要进行公共字段自动填充的方法。

注解中声明一个枚举类型的属性，用于指定当前方法的操作类型（INSERT/UPDATE），让切面类能根据注解值判断需要填充哪些字段：

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; /** * 自定义注解，标记需要进行公共字段自动填充的Mapper方法 */ @Target(ElementType.METHOD) // 注解仅作用于方法 @Retention(RetentionPolicy.RUNTIME) // 运行时有效，让AOP能获取注解信息 public @interface AutoFill { // 必须指定操作类型：INSERT/UPDATE OperationType value(); }

这个注解就像一个 “标签”，后续 AOP 切面会专门拦截所有贴了这个标签的方法，对其进行增强处理。

3. 常量类：AutoFillConstant—— 避免硬编码，统一管理反射方法名

在后续的反射操作中，我们需要调用实体类的setCreateTime、setCreateUser等 setter 方法为字段赋值。如果直接在代码中写死这些方法名字符串，会出现硬编码问题，后续修改方法名时需要多处改动，极易遗漏。

因此定义一个常量类，将所有需要反射调用的 setter 方法名统一定义为常量，提升代码的可维护性：

package com.sky.constant; /** * 公共字段自动填充常量类，管理反射所需的setter方法名 */ public class AutoFillConstant { /** * 创建时间setter方法名 */ public static final String SET_CREATE_TIME = "setCreateTime"; /** * 修改时间setter方法名 */ public static final String SET_UPDATE_TIME = "setUpdateTime"; /** * 创建人setter方法名 */ public static final String SET_CREATE_USER = "setCreateUser"; /** * 修改人setter方法名 */ public static final String SET_UPDATE_USER = "setUpdateUser"; }

4. 切面类：AutoFillAspect—— 核心执行者，AOP 拦截 + 反射赋值

这是整个公共字段自动填充方案的核心类，作为 AOP 的切面，它承担了 “拦截方法→解析注解→获取数据→反射赋值” 的全部工作。核心使用@Before前置通知，在 Mapper 方法执行之前完成字段填充，保证填充后的数据能被正常入库。

核心实现逻辑

1. 精准拦截：拦截com.sky.mapper包下所有带有@AutoFill注解的方法；
2. 解析注解：从拦截的方法上获取@AutoFill注解，得到操作类型（INSERT/UPDATE）；
3. 获取填充数据：
   • 时间数据：通过LocalDateTime.now()获取当前系统时间；
   • 用户 ID 数据：通过之前封装的BaseContext.getCurrentId()获取当前登录用户 ID（线程隔离的用户 ID）；
4. 获取方法参数：从 Mapper 方法的参数中，提取需要赋值的实体对象（如 Employee、Dish 等）；
5. 反射赋值：根据操作类型，通过反射调用实体对象的对应 setter 方法，为公共字段赋值。

完整切面代码实现

package com.sky.aspect; import com.sky.annotation.AutoFill; import com.sky.constant.AutoFillConstant; import com.sky.enumeration.OperationType; import com.sky.utils.BaseContext; 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; /** * 公共字段自动填充切面类，拦截带有@AutoFill注解的Mapper方法，实现字段自动赋值 */ @Aspect @Component @Slf4j public class AutoFillAspect { /** * 定义切入点：拦截com.sky.mapper包下所有带有@AutoFill注解的方法 */ @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)") public void autoFillPointCut() {} /** * 前置通知：在切入点方法执行前执行，完成公共字段填充 */ @Before("autoFillPointCut()") public void autoFill(JoinPoint joinPoint) { log.info("开始执行公共字段自动填充..."); // 1. 获取当前拦截方法上的@AutoFill注解，解析操作类型 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class); OperationType operationType = autoFill.value(); // 2. 获取当前拦截方法的参数（实体对象），如Employee、Dish等 Object[] args = joinPoint.getArgs(); if (args == null || args.length == 0) { return; } Object entity = args[0]; // 约定Mapper方法第一个参数为需要赋值的实体对象 // 3. 获取需要填充的公共数据 LocalDateTime now = LocalDateTime.now(); // 当前时间 Long currentUserId = BaseContext.getCurrentId(); // 当前登录用户ID // 4. 根据操作类型，通过反射为实体对象的对应字段赋值 try { // 获取实体对象的Class对象，用于反射调用方法 Class<?> entityClass = entity.getClass(); // 获取各个setter方法 Method setCreateTime = entityClass.getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class); Method setUpdateTime = entityClass.getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class); Method setCreateUser = entityClass.getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class); Method setUpdateUser = entityClass.getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class); // 根据操作类型执行不同的赋值逻辑 if (operationType == OperationType.INSERT) { // 新增操作：填充4个字段 setCreateTime.invoke(entity, now); setCreateUser.invoke(entity, currentUserId); setUpdateTime.invoke(entity, now); setUpdateUser.invoke(entity, currentUserId); } else if (operationType == OperationType.UPDATE) { // 修改操作：填充2个字段 setUpdateTime.invoke(entity, now); setUpdateUser.invoke(entity, currentUserId); } } catch (Exception e) { log.error("公共字段自动填充失败", e); throw new RuntimeException("公共字段自动填充失败"); } } }

关键细节说明

• 切入点设计：通过execution表达式精准匹配 mapper 包下的方法，结合@annotation实现 “仅拦截带有 @AutoFill 注解的方法”，避免无意义的拦截；
• 参数约定：约定 Mapper 方法的第一个参数为需要赋值的实体对象，简化参数提取逻辑；
• 异常处理：对反射过程中的异常进行捕获并封装，保证报错信息清晰，便于问题排查；
• 依赖 BaseContext：用户 ID 的获取依赖之前封装的 ThreadLocal 工具类，保证在当前请求线程中能获取到登录用户 ID，实现线程安全。

三、实战使用：一行注解，实现自动填充

完成四大核心组件的封装后，在项目中使用公共字段自动填充功能变得极其简单，只需在Mapper 接口的方法上添加 @AutoFill 注解，并指定操作类型，无需修改任何 Service 层代码，程序会自动完成字段赋值。

1. Mapper 层：添加注解，标记需要自动填充的方法

在 Mapper 接口的新增、修改方法上，添加@AutoFill注解并指定对应的操作类型（INSERT/UPDATE），这是开发者唯一需要做的操作：

package com.sky.mapper; import com.sky.annotation.AutoFill; import com.sky.entity.Employee; import com.sky.enumeration.OperationType; import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Update; public interface EmployeeMapper { /** * 新增员工，添加@AutoFill注解，指定INSERT操作 */ @AutoFill(OperationType.INSERT) @Insert("insert into employee (name, username, password, phone, sex, id_number, status, create_time, update_time, create_user, update_user) " + "values (#{name}, #{username}, #{password}, #{phone}, #{sex}, #{idNumber}, #{status}, #{createTime}, #{updateTime}, #{createUser}, #{updateUser})") void insert(Employee employee); /** * 修改员工信息，添加@AutoFill注解，指定UPDATE操作 */ @AutoFill(OperationType.UPDATE) @Update("update employee set name=#{name}, phone=#{phone}, sex=#{sex}, id_number=#{idNumber}, update_time=#{updateTime}, update_user=#{updateUser} where id=#{id}") void update(Employee employee); }

2. Service 层：无需任何赋值代码，简洁优雅

添加完注解后，Service 层的代码变得极度简洁，无需再手动设置createTime、updateUser等公共字段，直接调用 Mapper 方法即可，剩下的工作全部由切面自动完成：

package com.sky.service.impl; import com.sky.entity.Employee; import com.sky.mapper.EmployeeMapper; import com.sky.service.EmployeeService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class EmployeeServiceImpl implements EmployeeService { @Autowired private EmployeeMapper employeeMapper; @Override public void save(Employee employee) { // 无需手动设置createTime、createUser、updateTime、updateUser // 无需手动设置updateTime、updateUser employee.setStatus(1); // 仅设置业务相关字段 employeeMapper.insert(employee); // 切面会在执行前自动填充公共字段 } @Override public void update(Employee employee) { // 无需手动设置updateTime、updateUser employeeMapper.update(employee); // 切面会在执行前自动填充公共字段 } }

对比之前需要写四行赋值代码的场景，现在的 Service 层代码干净整洁，完全消除了重复的机械代码，开发者可以专注于业务逻辑的实现。

四、执行流程：程序运行时的自动填充链路

当项目运行起来后，调用employeeMapper.insert(employee)或employeeMapper.update(employee)时，整个公共字段自动填充的流程会自动触发，全程无需人工干预，具体执行步骤如下：

1. 调用 Mapper 方法：Service 层调用带有@AutoFill注解的 Mapper 方法，传入实体对象；
2. AOP 拦截：AutoFillAspect 切面通过切入点表达式拦截到该方法，触发前置通知autoFill方法；
3. 解析注解和参数：切面从方法上解析出@AutoFill注解的操作类型，从方法参数中提取出需要赋值的实体对象；
4. 获取填充数据：切面获取当前系统时间和 BaseContext 中的当前登录用户 ID；
5. 反射赋值：切面根据操作类型，通过反射调用实体对象的对应 setter 方法，为公共字段赋值；
6. 执行原方法：反射赋值完成后，切面放行，执行 Mapper 方法的原始 SQL 操作，此时实体对象的公共字段已被正确赋值，数据正常入库。

整个流程一气呵成，对开发者来说完全是 “透明” 的，既不影响原有代码的执行逻辑，又能自动完成重复的赋值工作。

五、方案优势：为什么说这是优雅的设计？

这套基于 AOP + 反射的公共字段自动填充方案，在实际项目中展现出了诸多优势，也是它被称为 “优雅设计” 的原因：

1. 消除重复代码，提升代码整洁度

将分散在各个 Service 层的公共字段赋值代码抽离出来，统一在切面中实现，彻底消除了重复代码，让业务代码更专注于核心逻辑。

2. 0 侵入式设计，符合开闭原则

无需修改原有 Mapper 接口和 Service 层的任何代码，只需添加注解即可实现功能，对原有代码无任何侵入，后续新增实体类时，只需保证实体类有对应的 setter 方法，即可直接使用该功能。

3. 统一管理，降低维护成本

所有公共字段的填充逻辑都集中在切面类中，后续如果需要修改填充规则（比如更换时间类型、修改用户 ID 的获取方式），只需修改切面类即可，无需逐个修改 Service 层代码；同时常量类避免了硬编码，让反射方法名的管理更规范。

4. 避免人为错误，提升开发效率

自动填充替代人工赋值，彻底避免了漏写、错写公共字段的问题；同时开发者无需再写机械的赋值代码，提升了开发效率，尤其在项目后期新增实体类时，效果尤为明显。

5. 线程安全，适配 Web 项目场景

用户 ID 的获取依托于 ThreadLocal 封装的 BaseContext 类，保证了在多线程环境下（Tomcat 线程池），每个请求线程都能获取到自己的用户 ID，不会出现数据混淆，适配 Web 项目的核心场景。

六、扩展与优化：让方案更通用

以上实现的是基础版的公共字段自动填充方案，在实际项目中，我们还可以对其进行扩展和优化，让方案的通用性更强：

1. 支持多参数适配：当前方案约定第一个参数为实体对象，可优化为遍历参数，自动识别实体对象类型，支持任意位置的实体参数；
2. 支持批量操作：扩展对List集合的支持，实现批量新增、批量修改时的公共字段自动填充；
3. 自定义填充字段：通过注解配置需要填充的字段，让方案不局限于固定的四个公共字段，适配更多业务场景；
4. 异常优雅处理：对反射中可能出现的 “方法不存在” 异常进行更细粒度的处理，比如忽略无对应 setter 方法的字段，避免整个填充流程失败。

七、总结

公共字段自动填充方案，是 AOP 和反射技术在实际项目中的经典结合应用，它的核心价值在于将重复、通用的逻辑从业务代码中抽离，通过面向切面的方式实现统一增强。

这套方案仅通过四个核心组件的配合，就实现了公共字段的自动化赋值，让开发者从机械的重复代码中解放出来，专注于业务逻辑的实现。同时，它的 0 侵入式设计、统一的管理方式和线程安全的特性，让代码更整洁、更易维护、更符合企业级开发的规范。

在实际项目中，这种 “抽离通用逻辑、通过切面增强” 的思想不仅适用于公共字段填充，还可应用于接口日志记录、参数校验、异常统一处理等场景。掌握这种思想，能让我们写出更优雅、更高效、更具可维护性的代码。