特性

为了简化MyBatis而生，只做增强，不做改变

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

快速入门

现在数据库有一张user表

id	name	age	email
1	Jone	18	test1@baomidou.com
2	Jack	20	test2@baomidou.com
3	Tom	28	test3@baomidou.com
4	Sandy	21	test4@baomidou.com
5	Billie	24	test5@baomidou.com

用初始化器初始化一个springboot项目

导入依赖

说明：我们使用MyBatisPlus可以节省我们大量的代码，尽量不要同时导入MyBatis和MyBatisPlus，可能存在版本差异

<!--数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!--MyBatisPlus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

连接数据库，和MyBatis相同

在springboot核心配置文件里配置一下

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=Asia/Shanghai&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

先看下传统方式接下来该咋办?

传统方式：pojo ---------> dao（连接mybatis，配置mapper.xml文件）---------> service ---------> controller

使用了mybatisplus后：

pojo
mapper接口
使用

创建实体类User

package com.pan.pojo;

import lombok.Data;

@Data//可自动生成getter和setter
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

创建mapper接口

package com.pan.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pan.pojo.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {//在对应的Mapper上面继承基本的类BaseMapper
    //所有的CRUD操作都已经编写完成了
    //你不需要像以前的配置一大堆文件了
}

在主启动类上加MapperScan注解

package com.pan;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.pan.mapper")///扫描我们的mapper文件夹
@SpringBootApplication
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}

测试

package com.pan.test;

import com.pan.mapper.UserMapper;
import com.pan.pojo.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.SpringJUnit4ClassRunner;

import java.util.List;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestDemo {
    @Autowired
    private UserMapper userMapper;//继承了BaseMapper,所有的方法都来自己父类,我们也可以编写自己的扩展方法！

    @Test
    public void test(){
        List<User> users = userMapper.selectList(null);// 测试查询
        users.forEach(System.out::println);
    }
}

开启日志功能，可以看到具体执行的sql是啥，在springboot核心配置文件里添加日志功能
```
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
```

CRUD

主键生成策略

www.cnblogs.com/haoxinyue/p…

插入

测试一下插入

package com.pan.test;

import com.pan.mapper.UserMapper;
import com.pan.pojo.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.SpringJUnit4ClassRunner;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestDemo {
    @Autowired
    private UserMapper userMapper;//继承了BaseMapper,所有的方法都来自己父类,我们也可以编写自己的扩展方法！

    @Test
    public void testInsert() {
        User user = new User();
        user.setName("tom");
        user.setAge(18);
        user.setEmail("1234@sdf");
        userMapper.insert(user);
        /*
         * ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
         * ==>  Parameters: 1582558466587791362(Long), tom(String), 18(Integer), 1234@sdf(String)
         * 发现自己插入了一长串id
         * 
         * 雪花算法
         * snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，
         * 10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫
         * 秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。
         * 具体实现的代码可以参看https://github.com/twitter/snowflake。
         * 雪花算法支持的TPS可以达到419万左右（2^22*1000）。
         * */
    }
}

默认id是唯一的，不写的话就相当于@TableId(type = IdType.ID_WORKER)

可以设置成自增，在实体类上加自增注解，再讲数据库该字段勾选成自增（不然报错）即可

package com.pan.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

@Data
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

不同注解的作用

@TableId(type = IdType.NONE)//未设置主键
@TableId(type = IdType.INPUT)//手动输入
@TableId(type = IdType.UUID)//也是全局唯一id
@TableId(type = IdType.ID_WORKER_STR)//@TableId(type = IdType.ID_WORKER)的字符串表示法

更新

@Test
public void testUpdate() {
    User user = new User();
    user.setId(1L);//改id为1的
    user.setName("sb");
    user.setAge(44);
    user.setEmail("55@sdf");
    int i = userMapper.updateById(user);
    System.out.println("影响了" + i + "行");
}

可以设置插入时间，更改时间（自动化的）

现在表中创建两个字段，update_time，insert_time，都是datetime类型的

然后在实体类上加TableField注解

package com.pan.pojo;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @TableField(fill = FieldFill.INSERT)
    private Date insertTime;//插入时自动更新
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;//更新时自动更新

}

然后编写处理器来处理这个注解即可

package com.pan.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component//别忘了加到IOC中
public class MyMetaObjectHandler implements MetaObjectHandler {
    // 插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("insertTime", new Date(), metaObject);// 只要一插入，就会自动给createTime字段插入new Date()
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    // 更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

测试插入和更新，发现自动填充了时间

查询

@Test
public void testSelectById() {
    User user = userMapper.selectById(1L);//根据id查
    System.out.println(user);
    /*
         * ==>  Preparing: SELECT id,name,age,email,version,insert_time,update_time FROM user WHERE id=?
         * ==> Parameters: 1(Long)
         * */
}

@Test
public void testSelectByBatchId() {
    ArrayList<Long> ids = new ArrayList<>();
    ids.add(1L);
    ids.add(2L);
    ids.add(3L);
    List<User> users = userMapper.selectBatchIds(ids);//根据id集合批量查
    users.forEach(System.out::println);
    /*
         * ==>  Preparing: SELECT id,name,age,email,version,insert_time,update_time FROM user WHERE id IN ( ? , ? , ? )
         * ==> Parameters: 1(Long), 2(Long), 3(Long)
         * */
}

@Test
public void testSelectByMap() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "tom");
    map.put("age", "18");
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
    /*
         * ==>  Preparing: SELECT id,name,age,email,version,insert_time,update_time FROM user WHERE name = ? AND age = ?
         * ==>  Parameters: tom(String), 18(String)
         * */
}

分页查询

配置拦截器组件

package com.pan.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisPlusConfig {
    // 分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

测试功能

@Test
public void testPage() {
    Page<User> pageInfo = new Page<>(1, 5);//表示查第1页，5个数据
    userMapper.selectPage(pageInfo, null);
    List<User> records = pageInfo.getRecords();
    records.forEach(System.out::println);
    // SELECT id,name,age,email,version,insert_time,update_time FROM user LIMIT 0,5
}

删除

@Test
public void testDelete() {
    int i = userMapper.deleteById(1L);// 通过id删除一个
    System.out.println("删除了" + i + "个");
}

@Test
public void testDelete() {
    ArrayList<Long> ids = new ArrayList<>();
    ids.add(1L);
    ids.add(2L);
    ids.add(3L);
    int i = userMapper.deleteBatchIds(ids);// 通过id集合批量删除
    System.out.println("删除了" + i + "个");
    // ==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? , ? ) 
    // ==> Parameters: 1(Long), 2(Long), 3(Long)
}

@Test
public void testDelete() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "tom");
    map.put("age", "18");
    int i = userMapper.deleteByMap(map);// 通过map集合条件删除
    System.out.println("删除了" + i + "个");
    // ==>  Preparing: DELETE FROM user WHERE name = ? AND age = ? 
    // ==> Parameters: tom(String), 18(String)
}

逻辑删除

物理删除：从数据库中直接移除逻辑删除：再数据库中没有被移除，而是通过一个变量来让他失效！deleted=0 => deleted=1

如：管理员可以查看被删除的记录！

在表中增加deleted字段，默认0

然后在实体类中加deleted属性，加注解TableLogic

package com.pan.pojo;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @TableLogic//逻辑删除
    private Integer deleted;
    
    @Version//乐观锁注解
    private Integer version;

    @TableField(fill = FieldFill.INSERT)
    private Date insertTime;//插入时自动更新
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;//更新时自动更新

}

添加逻辑删除插件

package com.pan.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisPlusConfig {
    //逻辑删除插件
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }
}

在springboot配置

#配置逻辑删除,设置默认没有删除为0
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

此时再删除发现走的是更新操作，只是将deleted标记改为了1

@Test
public void testDelete() {
    HashMap<String, Object> map = new HashMap<>();
    map.put("name", "Sandy");
    int i = userMapper.deleteByMap(map);// 通过map集合条件删除
    System.out.println("删除了" + i + "个");
    // ==>  Preparing: UPDATE user SET deleted=1 WHERE name = ? AND deleted=0
    // ==> Parameters: Sandy(String)
}

此时再查询发现会拼接一个标记，查不到了

// ==> Preparing: SELECT id,name,age,email,deleted,version,insert_time,update_time FROM user WHERE id=? AND deleted=0 
// ==> Parameters: 4(Long)

乐观锁悲观锁

乐观锁：故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，再次更新值测试悲观锁：故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！

当要更新一条记录的时候，希望这条记录没有被别人更新，简单来说可以给所有的记录加一个version，更新时看看当前version和老version是否相同 乐观锁实现方式：

取出记录时，获取当前 version
更新时，带上这个 version
执行更新时， set version = newVersion where version = oldVersion
如果 version 不对，就更新失败

乐观锁：1、先查询，获得版本号version=1

A
update user set name ="tom", version = version + 1 where id = 2 and version = 1

假如B线程抢先完成，这个时候version=2,会导致A修改失败
update user set name = "jerry",version = version + 1 where id = 2 and version = 1

在表中添加version字段，默认值设置为1

然后在实体类中加version字段，并加version注解

package com.pan.pojo;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;

    @Version//乐观锁注解
    private Integer version;

    @TableField(fill = FieldFill.INSERT)
    private Date insertTime;//插入时自动更新
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;//更新时自动更新

}

注册组件

package com.pan.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisPlusConfig {
    // 注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

@Test
public void testOptimisticLocker() {
    User user = userMapper.selectById(1L);
    user.setName("qwerqwer");
    user.setAge(33);
    user.setEmail("ccccccccccccccc");
    userMapper.updateById(user);
    // ==>  Preparing: UPDATE user SET name=?, age=?, email=?, version=?, update_time=? WHERE id=? AND version=? 
    // ==> Parameters: qwerqwer(String), 33(Integer), ccccccccccccccc(String), 2(Integer), 2022-10-19 11:45:28.762(Timestamp), 1(Long), 1(Integer)
}

条件构造器

写一些复杂的sql可以用构造器替代

package com.pan.test;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.pan.mapper.UserMapper;
import com.pan.pojo.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.SpringJUnit4ClassRunner;

import java.sql.Wrapper;
import java.util.List;
import java.util.Map;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class WrapperTest {
    @Autowired
    private UserMapper userMapper;//继承了BaseMapper,所有的方法都来自己父类,我们也可以编写自己的扩展方法！

    @Test
    public void testComplexSelect1() {
        // 如查询name不为空，且邮箱不为空，且年龄大于等于12的用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.isNotNull("name").isNotNull("email").ge("age", 12);
        userMapper.selectList(queryWrapper).forEach(System.out::println);
        // ==>  Preparing: SELECT id,name,age,email,deleted,version,insert_time,update_time FROM user WHERE name IS NOT NULL AND email IS NOT NULL AND age >= ?
        // ==> Parameters: 12(Integer)
    }

    @Test
    public void testComplexSelect2() {
        // 如查询name为Sandy的用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.eq("name", "Sandy");
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
        // ==>  Preparing: SELECT id,name,age,email,deleted,version,insert_time,update_time FROM user WHERE name = ?
        // ==> Parameters: Sandy(String)
    }

    @Test
    public void testComplexSelect3() {
        // 如查询age大于21小于100的用户数量
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.between("age", 21, 100);//区间
        Integer count = userMapper.selectCount(queryWrapper);
        System.out.println(count);
        // ==>  Preparing: SELECT COUNT(1) FROM user WHERE age BETWEEN ? AND ?
        // ==> Parameters: 21(Integer), 100(Integer)
    }

    @Test
    public void testComplexSelect4() {
        // 如模糊查询，找出名字中不含B且包含S的用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.notLike("name", "B").like("name", "S");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
        // ==>  Preparing: SELECT id,name,age,email,deleted,version,insert_time,update_time FROM user WHERE name NOT LIKE ? AND name LIKE ?
        // ==> Parameters: %B%(String), %S%(String)
    }

    @Test
    public void testComplexSelect5() {
        // 子查询，id是在子查询中查出来的
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.inSql("id", "select id from user where name = 'Sandy'");
        List<Object> users = userMapper.selectObjs(queryWrapper);
        users.forEach(System.out::println);
        // ==>  Preparing: SELECT id,name,age,email,deleted,version,insert_time,update_time
        //                 FROM user WHERE id IN (select id from user where name = 'Sandy')
    }

    @Test
    public void testComplexSelect6() {
        // 通过id排序
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();//类似于map
        queryWrapper.orderByDesc("id");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
        // SELECT id,name,age,email,deleted,version,insert_time,update_time FROM user WHERE deleted=0 ORDER BY id DESC 
    }
}

自动生成代码

引入依赖

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>

运行主方法即可

package com.pan;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CodeGenerator2 {
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 0 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 1 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("pan");//作者
        gc.setOpen(false);//是否打开windows的资源管理器
        gc.setFileOverride(false);//是否覆盖
        gc.setServiceName("%sService");//去掉Service的I前缀
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        // gc.setSwagger2(true);//Swagger2
        mpg.setGlobalConfig(gc);

        // 2 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=Asia/Shanghai&useSSL=false");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 3 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("test");
        pc.setParent("com.pan");
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        // 4 自定义配置
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");//设置要映射那些表
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);//自动lombok
        strategy.setLogicDeleteFieldName("deleted");//是否开启逻辑删除
        // 设置自动填充策略
        TableFill insertTime = new TableFill("insert_time", FieldFill.INSERT);
        TableFill updateTime = new TableFill("update_time", FieldFill.INSERT_UPDATE);
        List<TableFill> tableFills = new ArrayList<>();
        tableFills.add(insertTime);
        tableFills.add(updateTime);
        strategy.setTableFillList(tableFills);
        // 乐观锁
        strategy.setVersionFieldName("version");

        mpg.execute();
    }

}