MyBatis-Plus 之自动填充

r囧r小猫 2022-12-15 11:28 65阅读 0赞

推荐：[MyBatis Plus汇总][MyBatis Plus]

## MyBatis-Plus 之自动填充 ##

一个业务场景就是当我们插入或者更新表数据时，数据库会自动帮我们插入或者更新表字段`create_time`、`update_time`。

那有人会问了，在创建表时不是可以这样设置吗？

`create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间'
      `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'

这样不也能实现自动填充吗？但这只是更新这两个固定的字段，如果在更新表数据时，除了`update_time`需要自动更新，还需要自动填充更新者信息呢？所以我们这里介绍MyBatis-Plus的自动填充。

首先创建一个数据库表，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70]

然后创建一个Spring Boot项目。

`pom.xml`如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.kaven</groupId>
        <artifactId>mybatis-plus</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.4.RELEASE</version>
            <relativePath/>
        </parent>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-webflux</artifactId>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.0</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.49</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

`application.yml`如下：

spring:
      application:
        name: mybatis-plus
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: ITkaven@123
        url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false
    
    server:
      port: 8085
    
    logging:
      level:
        root: warn
        com.kaven.mybatisplus.dao: trace
      pattern:
        console: '%p%m%n'
    
    mybatis-plus:
      global-config:
        db-config:
          logic-delete-value: 1
          logic-not-delete-value: 0

实体类User：

package com.kaven.mybatisplus.entity;
    
    import com.baomidou.mybatisplus.annotation.*;
    import lombok.Data;
    
    import java.time.LocalDateTime;
    
    @TableName("user")
    @Data
    public class User{ 
    
        @TableId
        private String id;
    
        @TableField(value = "username")
        private String username;
    
        @TableField(value = "password")
        private String password;
    
        @TableField(value = "age")
        private Integer age;
    
        @TableLogic
        @TableField(value = "deleted")
        private Integer deleted;
    
        @TableField(value = "create_time" , fill = FieldFill.INSERT)
        private LocalDateTime createTime;
    
        @TableField(value = "update_time" , fill = FieldFill.INSERT_UPDATE)
        private LocalDateTime updateTime;
    
        /** * 使用 @TableField(exist = false) ，表示该字段在数据库中不存在 ，所以不会插入数据库中 * 使用 transient 、 static 修饰属性也不会插入数据库中 */
        @TableField(exist = false)
        private String phone;
    }

`fill = FieldFill.INSERT`、`fill = FieldFill.INSERT_UPDATE`这两个属性设置是关键。

FieldFill枚举类源码：

package com.baomidou.mybatisplus.annotation;
    
    public enum FieldFill { 
        /** * 默认不处理 */
        DEFAULT,
        /** * 插入时填充字段 */
        INSERT,
        /** * 更新时填充字段 */
        UPDATE,
        /** * 插入和更新时填充字段 */
        INSERT_UPDATE
    }

Mapper接口UserMapper：

package com.kaven.mybatisplus.dao;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.kaven.mybatisplus.entity.User;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public interface UserMapper extends BaseMapper<User> { }

启动类：

package com.kaven.mybatisplus;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    @MapperScan(basePackages = "com.kaven.mybatisplus.dao")
    public class AppRun { 
        public static void main(String[] args) { 
            SpringApplication.run(AppRun.class , args);
        }
    }

`@MapperScan(basePackages = "com.kaven.mybatisplus.dao")`这个一定要加上。

想要使用MyBatis-Plus的自动填充，还要创建一个类来实现MyBatis-Plus的MetaObjectHandler接口：

从上面的代码可以看出，其实就是实现一些自动填充的逻辑，插入时填充`createTime`、`updateTime`，更新时填充`updateTime`，和实体类中注解`@TableField()`的`fill`属性设置是对应的。

我们来测试一下自动填充是否生效。

插入测试代码：

package com.kaven.mybatisplus.dao;
    
    import com.kaven.mybatisplus.entity.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AutoFillTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void insert(){ 
            User user = new User();
            user.setUsername("mybatis plus");
            user.setPassword("very nice");
            user.setAge(22);
    
            int rows = userMapper.insert(user);
            System.out.println("影响行数： "+rows);
        }
    }

结果如下：

DEBUG==>  Preparing: INSERT INTO user ( id, username, password, age, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
    DEBUG==> Parameters: 1317005949376053249(String), mybatis plus(String), very nice(String), 22(Integer), 2020-10-16T15:34:21.781(LocalDateTime), 2020-10-16T15:34:21.781(LocalDateTime)
    DEBUG<==    Updates: 1
    影响行数： 1

很显然自动填充生效了，插入时填充了`createTime`、`updateTime`。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 1]

更新测试代码：

package com.kaven.mybatisplus.dao;
    
    import com.kaven.mybatisplus.entity.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AutoFillTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void update(){ 
            User user = new User();
            user.setId("1317005949376053249");
            user.setUsername("mybatis plus");
            user.setPassword("very nice , update");
            user.setAge(25);
    
            int rows = userMapper.updateById(user);
            System.out.println("影响行数： "+rows);
        }
    }

结果如下：

DEBUG==>  Preparing: UPDATE user SET username=?, password=?, age=?, update_time=? WHERE id=? AND deleted=0
    DEBUG==> Parameters: mybatis plus(String), very nice , update(String), 25(Integer), 2020-10-16T15:38:06.445(LocalDateTime), 1317005949376053249(String)
    DEBUG<==    Updates: 1
    影响行数： 1

结果也是正确的，更新时填充了`updateTime`。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 2]  
再来扩展一下自动填充。  
比如有一个业务如下:

*  插入时，如果实体类有`insert`字段，就自动填充`createTime`、`updateTime`，否则不进行自动填充`createTime`、`updateTime`。
 *  更新时，我们可以自己设置`updateTime`（用我们设置的`updateTime`进行自动填充），也可以不自己设置`updateTime`（用默认方法进行自动填充）。

我们需要修改MyMetaObjectHandler类：

package com.kaven.mybatisplus.component;
    
    import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
    import org.apache.ibatis.reflection.MetaObject;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    import java.util.Objects;
    
    @Component
    public class MyMetaObjectHandler implements MetaObjectHandler { 
        @Override
        public void insertFill(MetaObject metaObject) { 
            boolean hasSetterUsername = metaObject.hasSetter("insert");
            System.out.println(hasSetterUsername);
            if(hasSetterUsername){ 
                System.out.println("有insert字段");
                setFieldValByName("createTime" , LocalDateTime.now() , metaObject);
                setFieldValByName("updateTime" , LocalDateTime.now() , metaObject);
            }
            else{ 
                System.out.println("没有insert字段");
            }
    
        }
    
        @Override
        public void updateFill(MetaObject metaObject) { 
            Object updateTimeVal = getFieldValByName("updateTime" , metaObject);
            if(Objects.nonNull(updateTimeVal)){ 
                System.out.println("有设置updateTime的值");
                setFieldValByName("updateTime" , updateTimeVal , metaObject);
            }
            else{ 
                System.out.println("没有设置updateTime的值");
                setFieldValByName("updateTime" , LocalDateTime.now() , metaObject);
            }
        }
    }

测试代码：

package com.kaven.mybatisplus.dao;
    
    import com.kaven.mybatisplus.entity.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AutoFillTest { 
    
        @Autowired
        private UserMapper userMapper;
    
       @Test
        public void insert(){ 
            User user = new User();
            user.setUsername("123");
            user.setPassword("456");
            user.setAge(22);
    
            int rows = userMapper.insert(user);
            System.out.println("影响行数： "+rows);
        }
    }

结果如下：

false
    没有insert
    DEBUG==>  Preparing: INSERT INTO user ( id, username, password, age, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
    DEBUG==> Parameters: 1317016839945089025(String), 123(String), 456(String), 22(Integer), null, null
    DEBUG<==    Updates: 1
    影响行数： 1

显然实体类User没有`insert`字段，所以它不会自动填充`createTime`、`updateTime`，会自动填充的情况就不演示了，只要实体类有`insert`字段即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 3]  
测试代码：

package com.kaven.mybatisplus.dao;
    
    import com.kaven.mybatisplus.entity.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.time.LocalDateTime;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AutoFillTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void update(){ 
            User user = new User();
            user.setId("1317016839945089025");
            user.setUsername("456");
            user.setPassword("789");
            user.setUpdateTime(LocalDateTime.now());
            user.setAge(25);
    
            int rows = userMapper.updateById(user);
            System.out.println("影响行数： "+rows);
        }
    }

结果如下：

有设置updateTime的值
    DEBUG==>  Preparing: UPDATE user SET username=?, password=?, age=?, update_time=? WHERE id=? AND deleted=0
    DEBUG==> Parameters: 456(String), 789(String), 25(Integer), 2020-10-16T16:23:58.391(LocalDateTime), 1317016839945089025(String)
    DEBUG<==    Updates: 1
    影响行数： 1

结果是正确的，没有设置`updateTime`的值就不演示了，知道用法即可。

MyBatis-Plus的自动填充就介绍到这里。

写博客是博主记录自己的学习过程，如果有错误，请指正，谢谢！

[MyBatis Plus]: https://kaven.blog.csdn.net/article/details/108982474
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70]: /images/20221123/503d55c5448f40a1acc9c53105e51c0e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 1]: /images/20221123/54ff5de4251243599cb82782fd57c508.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 2]: /images/20221123/ff74178eadd94afbae9c687912f1c6a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTYwNjAz_size_16_color_FFFFFF_t_70 3]: /images/20221123/739dd60a216c4ec9b70711d06ad4074c.png