一、MyBatis-Plus介绍

官网 https://baomidou.com/

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变（无侵入式），为简化开发、提高效率而生。

MyBatis-Plus为简化开发而生。

二、MyBatis-Plus入门案例

2.1 基础环境准备

User表

-- 创建表
DROP TABLE IF EXISTS user;
CREATE TABLE user(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

-- 插入数据
INSERT INTO user (id, name, age, email) VALUES
(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');

2.2 SpringBoot整合MyBatis-Plus

2.2.1 导入依赖和配置yml

pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.10</version>
    <relativePath/>
</parent>
...
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!-- springboot整合mybatis-plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--springboot测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

application.yml

#配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis-plus?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456

#日志
logging:
  level:
    cn.msk1024: trace

2.2.2 准备接口和实体类

User实体类

package cn.msk1024.domain;
import ...
@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

UserMapper接口

package cn.msk1024.mapper;
import ...
/**
 * 我们自己的持久层接口继承BaseMapper接口，泛型指定为实体类User
 * BaseMapper接口由mybatis-plus提供，内置了很多CRUD操作。
 */
public interface UserMapper extends BaseMapper<User> {

}

2.2.3 启动类

@SpringBootApplication
@MapperScan("cn.msk1024.mapper") //扫描持久层接口
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2.2.4 测试基于mapper的CRUD接口

@SpringBootTest
public class MybatisPlusTest {

    @Autowired
    private UserMapper userMapper;
	
	//基于id查询
    @Test 
    public void testSelectById() {
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
   	//查询所有
    @Test
    public void testSelectAll() {
        //查询所有，没有查询条件所以传入null
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);

        //还有很多select方法，都需要Wrapper的支持，这里先不进行测试
        /*
        // 根据 entity 条件，查询一条记录
        T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        // 查询（根据ID 批量查询）
        List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
        // 根据 entity 条件，查询全部记录
        List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        // 查询（根据 columnMap 条件）
        List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
        // 根据 Wrapper 条件，查询全部记录
        List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
        List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

        // 根据 entity 条件，查询全部记录（并翻页）
        IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        // 根据 Wrapper 条件，查询全部记录（并翻页）
        IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
        // 根据 Wrapper 条件，查询总记录数
        Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
         */
    }

    /**
     * 插入一条记录
     * int insert(T entity);
     */
    @Test
    public void testInsert() {
        User u = new User();
        u.setId(6L);
        u.setName("张三");
        u.setAge(30);
        u.setEmail("111@1.com");
        userMapper.insert(u);
    }

    /**
     * 1.根据 whereWrapper 条件，更新记录
     * int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
     * 2.根据 ID 修改
     * int updateById(@Param(Constants.ENTITY) T entity);
     */
    @Test //修改
    public void testUpdateById() {
        User u1 = new User();
        u1.setId(6L);
        u1.setName("李四");
        u1.setAge(40);
        u1.setEmail("2222@1.com");
        userMapper.updateById(u1); //基于id修改

        //基于条件修改的其他方法（后边说）：int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);
    }

    /**
     * 1.根据 entity 条件，删除记录
     * int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
     * 2.删除（根据ID 批量删除）
     * int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
     * 3.根据 ID 删除
     * int deleteById(Serializable id);
     * 4.根据 columnMap 条件，删除记录
     * int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
     */
    @Test //删除
    public void testDelete() {
        //1.基于id删除
        userMapper.deleteById(6L);
        //2.基于id批量删除
        userMapper.deleteBatchIds(Arrays.asList(4L,5L));
        //3.基于map封装的条件删除
        Map<String,Object> map = new HashMap<>();
        map.put("name","Tom"); //参数1：字段名，参数2：字段值
        userMapper.deleteByMap(map);

        //基于条件删除的其他方法（后边说）：int delete(@Param("ew") Wrapper<T> queryWrapper);
    }
}

这里就可以看出MyBatis-Plus的好处，咱们sql语句都不用写就可以完成操作，但是代码上和mybatis的使用是几乎是一致的。

2.3 基于Service的CRUD接口

上边我们测试了mybatis-plus基于mapper做的封装，他还对service进行了相关的封装，我们的业务层接口只需要去继承 IService接口即可，其进一步封装了 CRUD，采用 get 查询单行， remove 删除， list 查询集合， page 分页 ，前缀命名方式区分 Mapper 层避免混淆。

相关代码案例参见 官网文档即可。

2.4 添加自己的SQL

如果mybatis-plus的提供方法不能满足自己的需求，就需要自己在mapper接口中写抽象方法和xml映射文件，并编写sql，流程和在mybatis中一致。
需要注意的是：application.yml配置加载映射文件的key要改为mybatis-plus.mapper-locations，其他都是一样的。

mybatis-plus:
  mapper-locations: classpath:mapper/*.xml

三、条件构造器Wrapper

前面咱们提到有些方法是需要传入一个Wrapper参数的，它是mybatis-plus提供的条件构造器的父类，条件构造器用于生成 sql 中的 where 条件，他有一个子类AbstractWrapper（抽象的）在其中定义了很多用于生产where条件的方法，常用的两个实现类有：QueryWrapper和 UpdateWrapper。

3.1 QueryWrapper

3.1.1 eq 等于 =

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testEq() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age","20"); //参数1:字段名，参数2：字段值
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }
}
//生成的SQL为：SELECT id,name,age,email FROM user WHERE (id = ?)

3.1.2 ne 不等于 <>

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;

    @Test //不等于 ne
    public void testNe() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("age", "20");
        List<User> userList = userMapper.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }
}
//生成的SQL: SELECT id,name,age,email FROM user WHERE (age <> ?)

3.1.3 范围相关的方法

使用方式和上边一样，以下案例就简写了。

1.gt 大于 >
例: gt("age", 18)---> age>18

2.ge 大于等于 >=
例: ge("age", 18)---> age>=18

3.lt 小于 <
例: lt("age", 18)---> age<18

4.le 小于等于 <=
例: le("age", 18)---> age<=18

5.between  在值1和值2范围中
例: between("age", 18, 30)---> age between 18 and 30

6.notBetween  不在值1和值2范围中
例：notBetween("age", 18, 30)---> age not between 18 and 30

3.1.4 like模糊查询

1.like
例: like("name", "王") ---> name like '%王%'

2.notLike
例: notLike("name", "王") ---> name not like '%王%'

3.likeLeft
例: likeLeft("name", "王") ---> name like '%王'

4.likeRight
例: likeRight("name", "王") ---> name like '王%'

3.1.5 Null值判断

1.isNull
例: isNull("name") ---> name is null

2.isNotNull
例: isNotNull("name") ---> name is not null

3.1.6 in 和 notIn

1.in
例：in("age",{1,2,3})--->age in (1,2,3)

2.notIn
例1: notIn("age",{1,2,3}) ---> age not in (1,2,3)
例2: notIn("age", 1, 2, 3)---> age not in (1,2,3)

3.1.7 inSql 和 notInSql

1.inSql
例1: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
例2: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)

2.notInSql
例1: notInSql("age", "1,2,3,4,5,6")--->age not in (1,2,3,4,5,6)
例2: notInSql("id", "select id from table where id < 3")--->id not in (select id from table where id < 3)

3.1.8 group by分组

1.groupBy
例: groupBy("id", "name") ---> group by id,name

2.having
例1: having("sum(age) > 10")      ---> having sum(age) > 10
例2: having("sum(age) > {0}", 11) ---> having sum(age) > 11

3.1.9 and 和 or

1.and
例: eq("id",1).and(i->i.eq("name","tom")) ---> id = 1 AND (name = 'tom')

2.or
例: eq("id",1).or().eq("name","老王")--->id = 1 or name = '老王'

3.1.10 select 设置查询字段

例: select("id", "name") ---> SELECT id,name FROM user

3.2 UpdateWrapper

1.set方法

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testUpdate() {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //设置修改的值 和 条件
        updateWrapper.set("name","tom").eq("id",1L);
        userMapper.update(new User(),updateWrapper);

        //SQL为：UPDATE user SET name=tom WHERE (id = 1)
    }
}

2.也可以分开编写修改的值和条件

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testUpdate() {
        //需要修改的数据
        User user = new User();
        user.setName("tom");
        //设置条件
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id",1L);
        userMapper.update(user,updateWrapper);
        
        //SQL为：UPDATE user SET name=tom WHERE (id = 1)
    }
}

四、主键策略

主键生成一般可以使用数据库自带的自增方式，例如：mysql的auto_increment。
在MyBatis-Plus中，他为我们提供了更为丰富的主键生成策略。

MyBatis-Plus默认实现5种主键生成策略，分别是：

• AUTO，配合数据库设置自增主键，可以实现主键的自动增长，类型为nmber；
• INPUT，由用户输入；
• NONE，不设置，等同于INPUT；
• ASSIGN_ID，只有当用户未输入时，采用雪花算法生成一个适用于分布式环境的全局唯一主键，类型可以是String和number；
• ASSIGN_UUID，只有当用户未输入时，生成一个String类型(UUID)的主键，但不保证全局唯一；

4.1 AUTO方式

需要注意：AUTO方式，数据库主键字段需设置为自增auto_increment
1.修改实体类，设置主键类型为：IdType.AUTO

@Data
@TableName("user") //指定表名
public class User {
    @TableId(type = IdType.AUTO) //使用数据库自增
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

2.测试

@SpringBootTest
public class MyBatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void t1(){
        User user = new User();
        user.setName("aa");
        user.setAge(20);
        userMapper.insert(user);
        
        //==> Preparing：INSERT INTO user ( name,age ) VALUES ( ?, ? )
        //==> Parameters：aa(String), 20(Integer)
        //<== Updates: 1
        //会发现将id赋值的工作交给了数据库自己。
    }
}

4.2 INPUT方式

1.设置主键类型为：IdType.INPUT

@Data
@TableName("user") 
public class User {
    @TableId(type = IdType.INPUT) //使用用户输入的方式
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

2.测试

@SpringBootTest
public class MyBatisPlusTest1 {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void t1(){
        User user = new User();
        user.setName("bb");
        user.setAge(20);
        userMapper.insert(user);
        //==> Preparing：INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
        //==> Parameters：null, bb(String), 20(Integer)
        //<== Updates: 1
        //就算我们没有显示的设置id，在sql中也会id字段（id赋值的活需要我们自己干）
        //所以在使用IdType.INPUT时一定记得自己设置id值，如果不设置并且数据库中id还不是自增的就会报错
    }
}

4.3 ASSIGN_ID方式

1.设置主键类型为：IdType.ASSIGN_ID

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.ASSIGN_ID) //使用雪花算法方式生成id
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

2.测试

@SpringBootTest
public class MyBatisPlusTest1 {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void t1(){
        User user = new User();
        user.setName("cc");
        user.setAge(20);
        userMapper.insert(user);
        //==> Preparing: INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
        //==> Parameters: 1573223858468675586(Long), cc(String), 20(Integer)
        //<== Updates: 1
        //会发现id的值是利用雪花算法生成的。
    }
}

4.4 ASSIGN_UUID方式

需要注意的是，在ASSIGN_UUID模式时，他生成的是UUID的随机字符串，长度为32位，所以表中主键id的类型需要改为varchar(32)，同时实体类User中的id属性类型要改为String。
1.修改表和实体类User

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.ASSIGN_UUID) //生成UUID
    private String id;
    private String name;
    private Integer age;
    private String email;
}

2.测试

@SpringBootTest
public class MyBatisPlusTest1 {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void t1(){
        User user = new User();
        user.setName("dd");
        user.setAge(20);
        userMapper.insert(user);
        //==> Preparing: INSERT INTO user ( id, name, age ) VALUES ( ?, ?, ? )
        //==> Parameters: d79219cafa6aa3f8eefd25b605237057(String), dd(String), 20(Integer)
        //<== Updates: 1
        //会发现id的值是UUID
    }
}

4.5 Sequence序列(了解)

mysql是可以为主键列设置自增属性的，但是其他数据库，例如：oracle就无法设置自增，但是他提供了一个类似的方式叫做：Sequence序列，使用序列依然可以实现自增的主键。
所以针对INPUT方式，如果不想自己输入id值，MyBatis-Plus自带的如下主键生成器生成：

• DB2KeyGenerator
• H2KeyGenerator
• KingbaseKeyGenerator
• OracleKeyGenerator
• PostgreKeyGenerator

以Oracle为例，使用步骤：
1.利用IKeyGenerator定义自己要用的主键生成器

@Configuration
public class MybatisPlusConfig {
    @Bean
    public IKeyGenerator keyGenerator() {
        return new OracleKeyGenerator(); //这里创建的是OracleKeyGenerator
    }
}

2.修改实体类

@Data
@TableName("user")
@KeySequence(value = "my_oracle_sequence") //指定序列名
public class User {
    @TableId(type = IdType.INPUT)
    private String id;
    private String name;
    private Integer age;
    private String email;
}
//以上要求数据库中已经存在my_oracle_sequence这个序列，在使用时，会调用SELECT my_oracle_sequence.NEXTVAL FROM DUAL来获取一个序列填充到主键中。

五、逻辑删除

逻辑删除：不是真的删除，而是使用一个字段来标记一行数据是否删除，例如：可以增加一个字段deleted，值为：1 - 已删除，值为：0 - 未删除。

5.1 准备数据

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL COMMENT '主键ID',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  `deleted` int(11) DEFAULT NULL COMMENT '逻辑删除(1-已删除,0-未删除)',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic //标记属性是“逻辑删除标识”属性
    private Integer deleted;
}

5.2 配置

在application.yml中追加逻辑删除的配置：

mybatis-plus:
  global-config:
    db-config:
      #logic-delete-field: deleted #全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置@TableLogic)
      logic-delete-value: 1        #逻辑已删除值(默认为 1)
      logic-not-delete-value: 0    #逻辑未删除值(默认为 0)

5.3 测试

1.对新增操作不会有任何影响

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert1() {
        User u = new User();
        u.setId(8L);
        u.setName("张三");
        u.setAge(30);
        u.setEmail("111@1.com");
        u.setDeleted(0); //我们约定新增的数据默认都是"未删除"状态，所以这里设置为：0
        userMapper.insert(u);
		
		//==> Preparing: INSERT INTO user ( id, name, age, email, deleted ) VALUES ( ?, ?, ?, ?, ? )
		//==> Parameters: 8(Long), 张三(String), 30(Integer), 111@1.com(String), 0(Integer)
		//<== Updates: 1
    }
}

2.查询操作，会自动追加 where 条件过滤掉已删除数据。

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testSelectAll1() {
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
        
        //SQL为: SELECT id,name,age,email,deleted FROM user WHERE deleted=0
    }
}

3.更新操作，会自动追加 where 条件防止更新到已删除数据

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test //修改
    public void testUpdateById() {
        User u1 = new User();
        u1.setId(6L);
        u1.setName("李四");
        u1.setAge(40);
        u1.setEmail("2222@1.com");
        userMapper.updateById(u1); 
		//==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=? AND deleted=0
		//==> Parameters: 李四(String), 40(Integer), 2222@1.com(String), 6(Long)
    }
}

4.删除操作，变为更新，仅将删除字段由0改为1

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testDelete1() {
        userMapper.deleteById(6L);
        //==> Preparing: UPDATE user SET deleted=1 WHERE id=? AND deleted=0
        //==> Parameters: 6(Long)
    }
}

六、自动填充

在第5节的新增案例中，需要每次新增时手动setDeleted(0)，又或者在新增和修改时，时间戳(新增时间，修改时间)字段也需要每次设置值。

MyBatis-Plus就为我们提供了自动设置默认值的操作。
使用@TableField(fill = FieldFill.INSERT)注解的方式来标记实体类中的哪些字段需要自动填充。
FieldFill是一个枚举，用于指定在何种情况下会自动填充，有如下几种可选值：

• DEFAULT：默认不处理
• INSERT：插入时自动填充字段
• UPDATE：更新时自动填充字段
• INSERT_UPDATE：插入和更新时自动填充字段

1.数据准备

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL COMMENT '主键ID',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  `deleted` int(11) DEFAULT NULL COMMENT '逻辑删除(1-删除,0-未删除)',
  `create_time` datetime DEFAULT NULL COMMENT '新增时间',
  `update_time` datetime DEFAULT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

@Data
@TableName("user")
public class User {
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic
    @TableField(fill = FieldFill.INSERT) //新增时填充
    private Integer deleted;
    @TableField(fill = FieldFill.INSERT) //新增时填充
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE) //新增和修改时填充
    private LocalDateTime updateTime;
}

2.自动填充的配置

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    //指定新增时的自动填充值
    @Override
    public void insertFill(MetaObject metaObject) {
        //1.设置新增时的时间字段
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐使用)
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
        // 或者
        //this.strictInsertFill(metaObject, "createTime", () -> LocalDateTime.now(), LocalDateTime.class); // 起始版本 3.3.3(推荐)
        // 或者
        //this.fillStrategy(metaObject, "createTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug)

        //2.设置新增时的逻辑删除字段
        this.strictInsertFill(metaObject,"deleted",Integer.class,0);
    }

    //指定修改时的自动填充值
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); // 起始版本 3.3.0(推荐)
        // 或者
        // this.strictUpdateFill(metaObject, "updateTime", () -> LocalDateTime.now(), LocalDateTime.class); // 起始版本 3.3.3(推荐)
        // 或者
        // this.fillStrategy(metaObject, "updateTime", LocalDateTime.now()); // 也可以使用(3.3.0 该方法有bug)
    }
}

3.测试

@SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;
    @Test
    public void testInsert1() {
        User u = new User();
        u.setId(12L);
        u.setName("张三");
        u.setAge(30);
        u.setEmail("111@1.com");
        userMapper.insert(u);
        //==> Preparing: INSERT INTO user ( id, name, age, email, deleted, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
        //==> Parameters: 12(Long), 张三(String), 30(Integer), 111@1.com(String), 0(Integer), 2022-09-23T22:27:03.709(LocalDateTime), 2022-09-23T22:27:03.712(LocalDateTime)
    }
}

七、分页

mybatisplus的mapper接口中提供了selectPage方法用于分页，但是执行该方法默认是全表查询，而不是分页，需要先配置 PaginationInnerInterceptor分页插件才会有效果。

7.1 配置PaginationInnerInterceptor

@Configuration
public class MybatisPlusConfig {
    //分页插件配置
    @Bean
    public MybatisPlusInterceptor paginationInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //对插件做相关设置
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
        //1.设置数据库类型，即：方言，这为设置的是mysql
        paginationInnerInterceptor.setDbType(DbType.MYSQL);
        //2.每页最大显示数量
        paginationInnerInterceptor.setMaxLimit(2L); //每页最多显示2条，就算每页时设置查10条，结果也是2条
        //3.请求的页数大于最大页后的操作：true调回首页，false继续执行查询，默认false
        paginationInnerInterceptor.setOverflow(false);
        //添加插件
        interceptor.addInnerInterceptor(paginationInnerInterceptor);
        return interceptor;
    }
}

7.2 执行分页

@SpringBootTest
public class MyBatisPlusTest2 {
    @Autowired
    private UserMapper userMapper;

    /**
     * 分页方法：
     * Page<E> selectPage(分页参数对象,条件构造器);
     */
    @Test
    public void testPage(){
    	//设置分页参数
        Page<User> page = new Page<>();
        page.setCurrent(1); //设置当前页
        page.setSize(5);    //每页显示条数
        
        //执行查询：
        Page<User> userPage = userMapper.selectPage(page, null);

        //获取结果：
        System.out.println("总条数："+userPage.getTotal());
        System.out.println("总页数："+userPage.getPages());
        System.out.println("当前页码："+userPage.getCurrent());
        System.out.println("每页显示条数(默认为10条)："+userPage.getSize());
        System.out.println("每页最多显示条数："+userPage.getMaxLimit());
        System.out.println("当前页数据："+userPage.getRecords());

        //mybatis-plus默认会执行自己的count查询操作获取总条数
        //如果想让他调用我们自己写的统计方法，则需要自己编写sql，并调用：page.setCountId("sqlId");
        System.out.println("获取CountId:"+userPage.getCountId());
    }
}

最后

以上就是想人陪猫咪为你收集整理的10-Java框架-SpringBoot整合MyBatis-Plus一、MyBatis-Plus介绍二、MyBatis-Plus入门案例三、条件构造器Wrapper四、主键策略五、逻辑删除六、自动填充七、分页的全部内容，希望文章能够帮你解决10-Java框架-SpringBoot整合MyBatis-Plus一、MyBatis-Plus介绍二、MyBatis-Plus入门案例三、条件构造器Wrapper四、主键策略五、逻辑删除六、自动填充七、分页所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。