Mybatis-plus核心功能及一些插件的配置

前言

Mybatis-plus（简称 MP）是一个Mybatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。本文基于mybatis_plus官方文档学习，主要对Mybatis-plus核心功能的CRUD接口、条件构造器、主键策略做个说明和扩展。在学习之前，需要对mybatis有所了解，可以参考博主以前的文章。（MP作者的愿景是让Mybatis-plus成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。）

一、第一个Mybatis-plus程序

1、创建一个springboot的项目，可以参考博主以前的博客：

如何用IDEA创建SpringBoot项目_全村第二帅的博客-CSDN博客_idea创建springboot项目步骤

2、导入相关依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3、创建一个数据库，库名为mybatis_plus，表名为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, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

4、配置数据库连接和输出日志

#数据库连接配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&useCharacter=UTF-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

5、配置实体类，使用lombok简化配置，无需再写set/get方法、toString方法

package com.study.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

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

6、编写UserMapper接口

可以直接在类上添加@Mapper注解，也可以在该类上加上@Repository注解、springboot启动类上加上@MapperScan("com.study.mapper")扫描mapper包的注解。然后在对应的Mapper上面继承基本的类BaseMapper，所有的CRUD操作依旧编写完成了，而不再需要像以前那样配置一大堆的文件了。

package com.study.mapper;

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

//在对应的Mapper上面继承基本的类BaseMapper
@Mapper
public interface UserMapper extends BaseMapper<User> {
    
}

阅读源码BaseMapper.java，可以发现该接口封装了许多CRUD的操作方法

7、编写测试类

@SpringBootTest
class MybatisPlusStudyApplicationTests {
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //查询全部的用户
        List<User> users = userMapper.selectList(null);
        //users.forEach(System.out::println);
        for (User user : users) {
            System.out.println(user);
        }
    }

我们编写一个测试类，查询所有的用户。使用selectList方法进行所有用户的查询，阅读源码可知，它的参数是一个条件构造器wrapper，且可以为空null。由于查询的是所有的用户，返回的是多条记录，所以用list集合接收，最后用增强for循环遍历输出，还可以用foreach遍历输出。（条件构造器后面再介绍，这里先不用）

8、测试结果

二、执行SQL打印

3.1.0 以下的版本叫性能分析插件，以上的版本叫作执行SQL分析打印。3.1.0以上的版本需要引入p6spy依赖。该插件有性能损耗，官方不建议我们在生产环境中使用，可以使用Druid数据源查看SQL执行（可以参照博主以往博客）。对于初学者来说，可以学习该插件，便于清楚地看到mybatis_plus怎么执行的SQL操作。

SpringBoot数据库连接池Druid的配置及log4j:WARN的解决_全村第二帅的博客-CSDN博客_springboot数据库连接池配置

1、首先导入p6spy依赖

<!-- p6spy 执行SQL分析打印 -->
        <dependency>
            <groupId>p6spy</groupId>
            <artifactId>p6spy</artifactId>
            <version>3.9.1</version>
        </dependency>

2、其次变更数据库的连接

#数据库连接配置
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&useCharacter=UTF-8
spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
#配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

3、然后配置spy.properties文件

modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=1

4、最后查看结果

三、主键策略

mybatis_plus支持多种主键生成策略，查看源码可知，它通过枚举类为我们提供多种生成方式。对于主键的生成方式，大概可以通过uuid，自增id，雪花算法，Redis，zookeeper等这些方式生成。

其通过在实体类中主键变量上添加注解@TableId，实现相应的主键自增策略

AUTO：数据库主键自增，需设置数据库自增（数据库需要支持主键自增，如：MySQL）

ASSIGN_ID：在比较早的版本，mybatis_plus默认使用ID_WORKER生成主键id，在新版本中，它默认使用ASSIGN_ID生成主键id，它们均会使用雪花算法自动生成主键ID（生成19位数字）。

NONE：不设置任何策略（注解里等于跟随全局，全局里约等于INPUT）

ASSIGN_UUID：使用UUID生成主键，随机唯一值

INPUT：可手动输入id

1、实体类上配置主键自增

@TableId(type =IdType.AUTO)//配置主键自增，数据库一定要是自增的
    private Long id;
@TableId(type =IdType.ASSIGN_ID)//该策略会使用雪花算法自动生成主键ID
    private Long id;
@TableId(type =IdType.NONE)//不设置任何策略，但是会跟随全局策略
    private Long id;
@TableId(type =IdType.INPUT)//自己定制id
    private Long id;

2、使用AUTO策略生成主键时，必须勾选数据库主键自动递增

不勾选自动递增，会出现以下的错误

3、测试

 @Test
    void testInsert() {
        User user = new User();
        user.setAge(13);
        user.setName("隔壁老王");
        user.setEmail("[email protected]");
        int insert = userMapper.insert(user);//会帮我们自动生成id
        System.out.println(insert);//受影响的行数
        System.out.println(user);
    }

4、结果

四、基本的CRUD操作

1、根据id进行更新操作

 @Test
    void testUpdate() {
        User user = new User();
        //通过条件自动拼接动态sql
        user.setId(7L);
        user.setName("范文");
        user.setAge(18);
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

2、根据id查询用户

 @Test
    void testSelectById() {
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

3、批量查询

BaseMapper.java里封装了selectBatchIds，该方法可以实现批量查询，参数是一个集合

 @Test
    void testSelectByBatchId() {
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3, 4));
        users.forEach(System.out::println);
    }

查询id=1,2,3,4的四个用户

4、按条件查询

使用方法selectByMap方法，该方法利用Map<String，Object>参数，实现根据字段查询特定的用户，比如：查询name字段为Jack的用户

@Test
    void test() {
        HashMap<String, Object> map = new HashMap<>();
        //自定义查询
        map.put("name", "Jack");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

查询出了名字是Jack的用户

5、删除操作

这里主要涉及按Id删除指定用户、批量删除用户、按某个特定条件删除用户，为了直观显示删除效果，这里采用逻辑删除。

 //测试删除
    //根据id删除
    @Test
    void testDelete() {
        userMapper.deleteById(7);
    }

    //批量删除
    @Test
    void testDelete2() {
        userMapper.deleteBatchIds(Arrays.asList(1528921098298281990L, 1529669686078959618L));
    }

    //通过map删除
    @Test
    void testDelete3() {
        HashMap<String, Object> map = new HashMap<>();
        map.put("name", "老王");
        userMapper.deleteByMap(map);
    }
    

五、条件构造器

Mybatis_plus可以通过条件构造器组成复杂的SQL语句，在第一个Mybatis_plus程序中，参数是一个条件构造器Wrapper，只是上面将其置为了null而已。在接口方法中，会出现各种Wrapper，比如：queryWrapper、updateWrapper 等。Wrapper 的作⽤就是⽤于定义各种各样的条件（where）。所以不管是查询、更新、删除都会用到Wrapper。一些条件判断的写法可参考官网：条件构造器 | MyBatis-Plus

1、queryWrapper

（1）查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于20的用户

@Test
    void contextLoads() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("name")
                .isNotNull("email")
                .ge("age", 20);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

（2）查询年龄小于18岁的且名字叫老王的信息

@Test
    void test2() {
        //查询年龄小于18岁的且名字叫老王的信息
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name", "老王").lt("age",18);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

（3）查询名字中不含"e"，且邮箱以t开头的用户信息

@Test
    void test4() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("name", "e")
                .likeRight("email", "t");
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

（4）查询年龄在20-50岁之间的用户，并按年龄降序排序，最后输出记录条数

 @Test
    void test3() {
        //查询年龄在20-50岁之间的用户，并按年龄降序排序，最后输出记录条数
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age", 20, 50).orderByDesc("age");//区间
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
        //输出查询结果数
        Long count = userMapper.selectCount(wrapper);
        System.out.println("共有多少条记录：" + count);
    }

（5）查询id小于6的用户，且查询出的用户年龄<20岁，使用子查询

@Test
    void test7(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.lt("age",20).inSql("id","select id from user where id<6");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

（6）查询名字为老姓或者年龄>=25的用户，按照年龄降序排序，年龄相同按照id升序排列

 @Test
    void test() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.likeRight("name", "老").or()
                .ge("age", 25)
                .orderByDesc("age")
                .orderByAsc("id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

（7）指定字段查询

可以查询指定的字段，比如：查询年龄大于30的用户名字，id，年龄

@Test
        //查询年龄大于30的用户名字，id，年龄
    void test9() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.select("id","name","age")
                .gt("age",30);
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

已知数据库中老滑头只有一个人，要求使用selectOne查询老滑头的姓名、年龄、邮箱。 注：selectOne返回的是一条实体记录，当出现多条时，会报错。

2、updateWrapper

将名字带有老王的或者年龄在20-30岁之间的用户都改成王富贵

@Test
    //将名字带有老王的或者年龄在20-30岁之间的用户都改成王富贵
    void test11(){
        //修改值
        User user=new User();
        user.setName("王富贵");
        //修改条件
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.like("name","老王")
                .or()
                .between("age",20,30);
        int result = userMapper.update(user, updateWrapper);
        System.out.println(result);
    }

六、一些插件配置

这里主要是对乐观锁插件、分页插件、逻辑删除插件进行配置。首先创建一个config包，在包里创建一个MybatisPlusConfig类。

package com.study.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableTransactionManagement
@Configuration //配置类
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        //注册乐观锁插件
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        //添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        //逻辑删除插件
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        return interceptor;
    }

}

1、乐观锁配置

乐观锁：假设数据一般情况不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果冲突，则返回给用户异常信息，让用户决定如何去做。简单来说，就是当要更新一条记录的时候，希望这条记录没有被别人更新。乐观锁比较适用于读多写少的情况。

悲观锁：具有强烈的独占和排他特性。它指的是对数据被外界(包括本系统当前的其他事务，以及来自外部系统的事务处理)修改持保守态度。悲观锁比较适用于写多读少的情况。

（1）实体类上的配置

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

（2） 测试类

//测试乐观锁成功
    @Test
    void testOptimisticLocker() {
        //1、查询用户信息
        User user = userMapper.selectById(1L);
        //2、修改用户信息
        user.setName("阿满");
        user.setEmail("[email protected]");
        //3、执行更新操作
        userMapper.updateById(user);
    }

（3）结果

注：多线程下，一个线程执行了插队操作，如果没有乐观锁原来的线程就会覆盖插队线程的值。

2、逻辑删除配置：逻辑删除是为了方便数据恢复和保护数据本身价值等等的一种方案。进行逻辑删除时，数据库的记录并未真正被删除，但再进行查询时，却查不出被逻辑删除的记录了。

（1）实体类上的配置

@TableLogic //逻辑删除
    private Integer deleted;

（2）测试类上的配置

//测试删除
    //根据id删除
    @Test
    void testDelete() {
        userMapper.deleteById(6);
    }

（3）配置文件中配置逻辑删除，1表示逻辑已删除，0表示逻辑未删除

#配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

（4）结果，6号在数据库中并没有真正被删除，但是逻辑上已被删除，字段deleted被置为1

3、分页插件配置：主要是对数据库查询分页，可以不用写limit等分页语句

（1）测试类上的配置

注：（1，3）是new Page<>(current，size)的两个参数，表示当前分页是第一页，每页三条记录也即查询出id=1,2,3三条记录（相当于limit（0,3））。（2，4）表示，当前分页为第二页，每页四条记录，也即查询出id=5,6,7,8四条记录（相当于limit（4,4））

//测试分页查询
    @Test
    void testPage() {
        Page<User> page = new Page<>(1, 3);
        userMapper.selectPage(page, null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

（2）结果

事实上，这个分页插件也是进行了limit的操作，下面显示查出了三条记录