Spring Boot 集成 Mybatis Plus 自动填充字段的实例详解

一般在表设计的时候，都会在表中添加一些系统字段，比如 create_time、update_time等。

阿里巴巴开发手册中也有这样的提示，如果对于这些公共字段可以进行统一处理，不需要每次进行插入或者更新操作的时候 set 一下，就可以提高开发效率，解放双手。

加入依赖

下面就通过 MyBatis Plus 来完成字段自动填充，首先加入 MyBatis Plus 依赖：

1. <dependency>
2.     <groupId>com.baomidou</groupId>
3.     <artifactId>mybatis-plus-boot-starter</artifactId>
4.     <version>3.4.1</version>
5. </dependency>

创建实体类，添加填充注解

创建一个实体类，然后在需要自动填充的属性上加注解 @TableField(fill = FieldFill.INSERT)、@TableField(fill = FieldFill.INSERT_UPDATE) 等注解。

1. @Data
2. @TableName("user")
3. public class UserEntity extends BaseEntity {
4.     private static final long serialVersionUID = 1L;
5.     /**
6.      * 主键
7.      */
8.     @TableId(value = "id", type = IdType.ASSIGN_ID)
9.     private Long id;
10.     /**
11.      * 姓名
12.      */
13.     @TableField("name")
14.     private String name;
15.     /**
16.      * 年龄
17.      */
18.     @TableField("age")
19.     private Integer age;
20.     /**
21.      * 邮件
22.      */
23.     @TableField("email")
24.     private String email;
25.     /**
26.      * 创建时间
27.      */
28.     @TableField(value = "create_time", fill = FieldFill.INSERT)
29.     public Date createTime;
30.     /**
31.      * 修改时间
32.      */
33.     @TableField(value = "modify_time", fill = FieldFill.INSERT_UPDATE)
34.     public Date modifyTime;
35. }

其中 fill 属性为字段自动填充策略，可选的参数如下所示：

1. public enum FieldFill {
2.     /**
3.      * 默认不处理
4.      */
5.     DEFAULT,
6.     /**
7.      * 插入填充字段
8.      */
9.     INSERT,
10.     /**
11.      * 更新填充字段
12.      */
13.     UPDATE,
14.     /**
15.      * 插入和更新填充字段
16.      */
17.     INSERT_UPDATE
18. }

就直接创建一个 Mapper，来便于测试：

1. @Mapper
2. public interface UserMapper extends BaseMapper<UserEntity> {
3. }

实现元对象处理器接口

MyBatis Plus 版本不同，实现方式可能会有些许不同，在 3.4.1 版本是实现 MetaObjectHandler 接口，低版本可能是继承 MetaObjectHandler 抽象类，来实现对应的方法。

下面为实现插入和更新数据的字段填充逻辑，在插入对象时，对创建时间 createTime 和修改时间 modifyTime 字段自动填充为当前时间，在更新对象时，将修改时间 modifyTime 修改为最新时间。

1. @Component
2. public class CommonMetaObjectHandler implements MetaObjectHandler {
3.     /**
4.      * 创建时间
5.      */
6.     private static final String FIELD_SYS_CREATE_TIME = "createTime";
7.     /**
8.      * 修改时间
9.      */
10.     private static final String FIELD_SYS_MODIFIED_TIME = "modifyTime";
11.  
12.     /**
13.      * 插入元对象字段填充（用于插入时对公共字段的填充）
14.      *
15.      * @param metaObject 元对象
16.      */
17.     @Override
18.     public void insertFill(MetaObject metaObject) {
19.         Date currentDate = new Date();
20.         // 插入创建时间
21.         if (metaObject.hasSetter(FIELD_SYS_CREATE_TIME)) {
22.             this.strictInsertFill(metaObject, FIELD_SYS_CREATE_TIME, Date.class, currentDate);
23.         }
24.         // 同时设置修改时间为当前插入时间
25.         if (metaObject.hasSetter(FIELD_SYS_MODIFIED_TIME)) {
26.             this.strictUpdateFill(metaObject, FIELD_SYS_MODIFIED_TIME, Date.class, currentDate);
27.         }
28.     }
29.  
30.     /**
31.      * 更新元对象字段填充（用于更新时对公共字段的填充）
32.      *
33.      * @param metaObject 元对象
34.      */
35.     @Override
36.     public void updateFill(MetaObject metaObject) {
37.         this.setFieldValByName(FIELD_SYS_MODIFIED_TIME, new Date(), metaObject);
38.     }
39. }

其中，默认填充策略为默认有值不覆盖，如果提供的值为 null 也不填充。如果默认填充策略不满足，可以重写 strictFillStrategy 方法以满足自己的需求。

测试字段自动填充

编写测试类来检验是否在插入和更新操作时，是否会自动填充响应的字段。

1. @Slf4j
2. @RunWith(SpringRunner.class)
3. @SpringBootTest
4. public class AutoFillTest {
5.     @Resource
6.     private UserMapper userMapper;
7.     @Test
8.     public void test() throws InterruptedException {
9.         UserEntity user = new UserEntity();
10.         user.setName("wupx");
11.         user.setAge(18);
12.         user.setEmail("wupx@qq.com");
13.         userMapper.insert(user);
14.         Long id = user.getId();
15.         UserEntity beforeUser = userMapper.selectById(id);
16.         log.info("before user:{}", beforeUser);
17.         Assert.assertNotNull(beforeUser.getCreateTime());
18.         Assert.assertNotNull(beforeUser.getModifyTime());
19.         beforeUser.setAge(19);
20.         Thread.sleep(1000L);
21.         userMapper.updateById(beforeUser);
22.         log.info("query user:{}", userMapper.selectById(id));
23.         // 清除测试数据
24.         userMapper.deleteById(id);
25.     }
26. }

启动测试类，通过日志可以看出来：

1. before user:UserEntity(id=1346071927831134210, name=wupx, age=18, email=wupx@qq.com, createTime=Mon Jan 04 20:32:11 CST 2021, modifyTime=Mon Jan 04 20:32:11 CST 2021)
2. query user:UserEntity(id=1346071927831134210, name=wupx, age=19, email=wupx@qq.com, createTime=Mon Jan 04 20:32:11 CST 2021, modifyTime=Mon Jan 04 20:32:13 CST 2021)

第一次插入对象的时候，创建时间和修改时间都自动填充了，当修改对象的时候，修改时间也相应的进行了更新。

另外可以将公共字段封装到公共类中，比如 BaseEntity：

1. @Data
2. public class BaseEntity {
3.     /**
4.      * 主键
5.      */
6.     @TableId(value = "id", type = IdType.ASSIGN_UUID)
7.     private Long id;
8.     /**
9.      * 创建时间
10.      */
11.     @TableField(value = "create_time", fill = FieldFill.INSERT)
12.     private Date createTime;
13.     /**
14.      * 修改时间
15.      */
16.     @TableField(value = "modify_time", fill = FieldFill.INSERT_UPDATE)
17.     private Date modifyTime;
18. }

经过测试，也是可以完成公共字段的自动填充，大家也可以在项目中这样搞下，可以减少每次插入或者更新时的 set 操作。

总结

本文的完整代码在 https://github.com/wupeixuan/SpringBoot-Learn 的 mybatis-plus-auto-fill-metainfo 目录下。

你有没有经常需要去设置公共字段的烦恼呢，如果有这种情况，可以通过这种方式来解决下。

❝

参考

https://github.com/wupeixuan/SpringBoot-Learn

https://baomidou.com/guide/auto-fill-metainfo.html

到此这篇关于Spring Boot 集成 Mybatis Plus 自动填充字段的文章就介绍到这了,更多相关Spring Boot 集成 Mybatis Plus 填充字段内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_27276045/article/details/112211109