MyBatis-Plus的使用

MyBatis-Plus

1、mybatis-plus介绍

官网：https://baomidou.com/

MyBatis-Plus （简称 MP）是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。MyBatis-Plus提供了通用的mapper和service，可以在不编写任何SQL语句的情况下，快速的实现对单表的CRUD批量、逻辑删除、分页等操作。

1.1、特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.2、支持数据库

任何能使用 MyBatis 进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，如果不在下列表查看分页部分教程 PR 您的支持。

• MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb，informix，TDengine，redshift
• 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库，优炫数据库

1.3、代码托管

• gitee：https://gitee.com/baomidou/mybatis-plus
• GitHub：https://github.com/baomidou/mybatis-plus

2、入门案例

2.1、开发环境

IDE： IDEA 2023.1

JDK：JDK8+

构建工具：maven3.8.3

MySQL版本：MySQL5.5.27

SpringBoot：2.7.6

mybatis-plus：3.5.3.1

2.2、创建数据库及表

-- 创建数据库
CREATE DATABASE mybatisplus;
-- 使用数据库
USE mybatisplus;
-- 创建表
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)
);

2.3、表中添加数据

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.4、创建SpringBoot项目

使用Spring Initializr 快速构建SpringBoot项目

项目中没有用途的几个文件可以删除

2.5、添加依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.qbzaixian</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- mybatis-plus的启动器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>
        <!-- lombok简化实体类开发，需要idea安装lombok的插件哦~~~-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.6、配置文件

spring:
  datasource:
    # 配置数据源类型
    type: com.zaxxer.hikari.HikariDataSource
    # 配置连接数据库的驱动
    driver-class-name: com.mysql.jdbc.Driver
    # 配置连接数据库的url
    url: jdbc:mysql://127.0.0.1:3306/mybatisplus?characterEncoding=utf-8&useSSL=false
    # 配置连接数据库的账号
    username: root
    # 配置连接数据库的密码
    password: 123

2.7、配置实体类

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

2.8、编写mapper接口

mybatis-plus提供了BaseMapper接口，其中提供大量的CRUD的方法，我们的接口只需要去继承这个接口，基本就可以实现对单表的CRUD操作。接口的泛型对应编写的实体类

public interface UserMapper extends BaseMapper<User> {
}

2.9、编写启动类

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹：

@SpringBootApplication
@MapperScan("com.qbzaixian.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

2.10、编写测试类

UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper，所以不填写就是无任何条件

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

    @Test
    public void testSelect(){
        // 接口中提供的selectList参数为条件，如果没有设置为null
        List<User> users = this.userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}

这里我选择降低SpringBoot的版本为2.7.6来解决这个问题。

 <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.7.6</version>
     <relativePath/> <!-- lookup parent from repository -->
 </parent

运行测试类，看到如下测试结果

通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

从以上步骤中，我们可以看到集成MyBatis-Plus非常的简单，只需要引入 starter 工程，并配置 mapper 扫描路径即可。

2.11、添加日志

希望看到mybatis-plus执行的具体过程和对应的sql语句，需要简单的配置mybatis-plus的日志即可

# 配置日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3、BaseMapper接口

mybatis-plus提供了BaseMapper接口，其中提供大量的CRUD的方法，我们的接口只需要去继承这个接口，基本就可以实现对单表的CRUD操作。接口的泛型对应编写的实体类

3.1、insert插入

参数说明

类型	参数名	描述
T	entity	实体对象

// 插入一条记录
int insert(T entity);

    // BaseMapper的新增功能
    // INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    @Test
    public void testInset(){
        User user = new User();
        user.setAge(20);
        user.setName("赵四");
        user.setEmail("zhaosi@qq.com");
        int result = this.userMapper.insert(user);
        System.out.println(result);
    }

温馨提示：添加完成之后，添加的新对象也会进行ID回显的，但ID值默认采用的是雪花算法计算出来的数据，不是一个自增长的值。

3.2、delete删除

参数说明

类型	参数名	描述
Wrapper	wrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键 ID 列表(不能为 null 以及 empty)
Serializable	id	主键 ID
Map<String, Object>	columnMap	表字段 map 对象

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    // BaseMapper的删除功能
    @Test
    public void testDel(){
        // 根据id删除 DELETE FROM user WHERE id=?
        int i = this.userMapper.deleteById(1L);
        // 根据实体对象的id删除 DELETE FROM user WHERE id=?
        User user= new User();
        user.setId(2L);
        int i2 = this.userMapper.deleteById(user);
        // 根据Collection集合删除（id列表）
        // DELETE FROM user WHERE id IN ( ? , ? , ? )
        List<Long> list = Arrays.asList(2L, 3L, 4L);
        this.userMapper.deleteBatchIds(list);
        // 根据指定的列属性删除
        // DELETE FROM user WHERE name = ? AND age = ?
        Map<String,Object> map = new HashMap<>();
        map.put("age",20);
        map.put("name","赵四");
        int i3 = this.userMapper.deleteByMap(map);
    }

3.3、update修改

在调用updateById方法前，需要在T entity（对应的实体类）中的主键属性上加上@TableId注解。

参数说明

类型	参数名	描述
T	entity	实体对象 (set 条件值,可为 null)
Wrapper	updateWrapper	实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

    @Test
    public void testUpdate(){
        // 根据id修改数据 UPDATE user SET name=?, email=? WHERE id=?
        User user = new User();
        user.setId(5L);
        user.setName("乔治");
        user.setEmail("qiaozhi@.qq.com");
        int i = this.userMapper.updateById(user);
    }

3.4、select查询

参数说明

类型	参数名	描述
Serializable	id	主键 ID
Wrapper	queryWrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键 ID 列表(不能为 null 以及 empty)
Map<String, Object>	columnMap	表字段 map 对象
IPage	page	分页查询条件（可以为 RowBounds.DEFAULT）

// 根据 ID 查询
T selectById(Serializable id);
// 根据 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);

-- 由于前面演示删除，修改等操作，数据库中的数据已经不多了，现在给数据库中重新插入部分数据
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');

    @Test
    public void testSelectAll(){
        // selectList:根据条件查询，如果没有条件书写为null
        // SELECT id,name,age,email FROM user
        List<User> users = this.userMapper.selectList(null);
        users.forEach(System.out::println);

        // selectById:根据id查询
        // SELECT id,name,age,email FROM user WHERE id=?
        User user = this.userMapper.selectById(5L);
        System.out.println(user);

        // selectCount:查询满足条件的记录数，如果没有条件书写为null
        // SELECT COUNT( * ) AS total FROM user
        Long count = this.userMapper.selectCount(null);
        System.out.println(count);

        // selectBatchIds：通过多个id列表查询
        // SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
        List<User> userList = this.userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
        userList.forEach(System.out::println);

        // selectByMap:根据指定map中的属性作为查询条件
        // SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
        Map<String,Object> map = new HashMap<>();
        map.put("name","乔治");
        map.put("age","20");
        List<User> list = this.userMapper.selectByMap(map);
        list.forEach(System.out::println);
    }

3.5、自定义接口方法

mybatis-plus主要是单表的操作，如果我们需要执行多表，或者执行自己书写的sql脚本与接口，mybatis-plus也支持指定的方式。

在mybaits-plus的MybatisPlusProperties 类中配置相关的属性配置，其中

private String[] mapperLocations = new String[]{"classpath*:/mapper/**/*.xml"};

用来加载指定路径下的xml映射文件的，当然如果你不喜欢这个路径，可以在SpringBoot的配置文件中进行修改

mybatis-plus:
config-location: 书写自己的路径

在项目resoureces 目录下，创建 mapper 文件夹，在其中创建UserMapper.xml 文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qbzaixian.mapper.UserMapper">
 <select id="selectUserById" resultType="map">
     select * from user where id = #{id}
 </select>
</mapper>

在接口中编写对应的查询方法

public interface UserMapper extends BaseMapper<User> {
 /**
     * 根据指定的id，查询user数据，返回map集合
     * @param id
     * @return
     */
    public Map<String,Object> selectUserById(Long id);
}

执行查询操作：

    @Test
    public void testMyQuery(){
        // 测试自定义的接口方法
        Map<String, Object> map = this.userMapper.selectUserById(1L);
        System.out.println(map);
    }

4、通用Service接口

mybatis-plus不仅提供通用的mapper接口，还提供通用的Service接口。

• 通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

4.1、IService接口

Mybatis-Plus中提供的IService接口和实现类ServiceImpl，封装了常见业务逻辑，可以简单查阅源码

public class ServiceImpl<M extends BaseMapper<T>, T> implements IService<T> {
    // 提供了大量的CRUD相关的方法
}

4.2、测试Service接口

通过前面的mapper接口的CRUD演示，针对Service接口中的大部分方法使用基本一致，这里就简单演示批量插入操作

虽然有ServiceImpl实现类和IService接口，但是大部分情况下还是需要根据对应的业务书写相关接口和实现类

// 在service包下创建UserService接口
public interface UserService extends IService<User> {
}
// 在service.impl包下创建UserServiceImpl实现类
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

准备进行测试

@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserServiceImpl userService;

    @Test
    public void testSaveBatch(){
        List<User> list = new ArrayList<>();
        for (int i = 1 ; i < 5 ; i++){
            User user = new User();
            user.setName("测试"+i);
            user.setAge(20+i);
            user.setEmail("test@163.com");
            list.add(user);

        }
        // 批量给数据库中插入数据，在mapper接口中是没有的
        boolean b = this.userService.saveBatch(list);
        System.out.println(b);
    }
}

5、注解介绍

mybatis-plus提供部分的注解，方便快速的进行表、属性、主键、主键生成策略等进行标注

5.1、@TableName注解

• 描述：表名注解，标识实体类对应的表
• 使用位置：实体类

@Data
@TableName("user")
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

一般用在实体类名与对应的表名不一致的情况下，当然如果项目中整个表名都有对应的前缀，也可以在SpringBoot的核心配置文件进行前缀的配置，省去注解的配置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 全局配置表名的前缀  
  global-config:
    db-config:
      table-prefix: tb_

5.2、@TableId注解

用于标注当前的实体类的id属性对应表的主键，mybatis-plus默认采用id属性作为主键。

• 描述：主键注解
• 使用位置：实体类主键字段

@Data
@TableName("user")
public class User {
    @TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

TableId注解的两个属性作用：

属性	类型	必须指定	默认值	描述
value	String	否	“”	主键字段名
type	Enum	否	IdType.NONE	指定主键类型

mybatis-plus在设置逐渐的时候ltype属性用来设置主键的生成策略：

@Data
@TableName("user")
public class User {
 @TableId(value='对应的表主键列名' , type=主键策略)
 private Long id;
 private String name;
 private Integer age;
 private String email;
}

关于type属性（主键策略）的枚举值IdType的详细介绍：

常用的有：

@TableId(value='对应的表主键列名' , type=idType.AUTO)
@TableId(value='对应的表主键列名' , type=idType.ASSIGN_ID)

值	描述
AUTO	数据库 ID 自增
NONE	无状态，该类型为未设置主键类型（注解里等于跟随全局，全局里约等于 INPUT）
INPUT	insert 前自行 set 主键值
ASSIGN_ID	分配 ID(主键类型为 Number(Long 和 Integer)或 String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法)
ASSIGN_UUID	分配 UUID,主键类型为 String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认 default 方法)
ID_WORKER	分布式全局唯一 ID 长整型类型(please use ASSIGN_ID)
UUID	32 位 UUID 字符串(please use ASSIGN_UUID)
ID_WORKER_STR	分布式全局唯一 ID 字符串类型(please use ASSIGN_ID)

关于主键生成策略，可以在SpringBoot的全局配置文件中进行配置

# 配置日志
mybatis-plus:
configuration:
 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
# 全局配置
global-config:
 db-config:
   # 配置表的名的前缀
   table-prefix: tb_
   # 配置主键生成策略
   id-type: auto

5.3、雪花算法

SnowFlake 中文意思为雪花，故称为雪花算法。最早是 Twitter 公司在其内部用于分布式环境下生成唯一 ID。在2014年开源 scala 语言版本。

雪花算法的原理就是生成一个的 64 位比特位的 long 类型的唯一 id。

• 最高 1 位固定值 0，因为生成的 id 是正整数，如果是 1 就是负数了。
• 接下来 41 位存储毫秒级时间戳，2^41/(1000606024365)=69，大概可以使用 69 年。
• 再接下 10 位存储机器码，包括 5 位 datacenterId 和 5 位 workerId。最多可以部署 2^10=1024 台机器。
• 最后 12 位存储序列号。同一毫秒时间戳时，通过这个递增的序列号来区分。即对于同一台机器而言，同一毫秒时间戳下，可以生成 2^12=4096 个不重复 id。
• 可以将雪花算法作为一个单独的服务进行部署，然后需要全局唯一 id 的系统，请求雪花算法服务获取 id 即可。

对于每一个雪花算法服务，需要先指定 10 位的机器码，这个根据自身业务进行设定即可。例如机房号+机器号，机器号+服务号，或者是其他可区别标识的 10 位比特位的整数值都行。

简单说雪花算法解决的问题：

• 需要选择合适的方案应对数据规模化的增长，以应对逐渐增长的访问压力与数据量。
• 数据库扩展方式主要包括：业务分库、主从复制、数据库分表等。

不同的编程语言，都有雪花算法的实现，可以直接调用对应的程序即可得到一个雪花算法值。

5.4、@TableField注解

作用：字段注解（非主键），解决表的属性名与实体中的属性名不一致问题。

@Data
@TableName("user")
public class User {
    @TableId
    private Long id;
    @TableField("nickname")
    private String name;
    private Integer age;
    private String email;
}

@TableField注解的属性比较多，常用的就是标注列名（即value属性，默认可以不写）

其他的属性如果需要，可以参考官方文档

5.5、@TableLogic注解

作用：表字段逻辑处理注解（逻辑删除）

物理删除：真实删除，将对应的数据从数据库中删除，之后查询不到此条被删除的数据

逻辑删除：假删除，将对应的数据中代表是否删除的字段状态修改被删除，在数据库可以查到这条数据记录，只是标记为被删除

使用场景：可以进行数据恢复

@Data
@TableName("user")
public class User {
    @TableId
    private Long id;
    @TableField("nickname")
    private String name;
    private Integer age;
    private String email;
    @TableLogic
    private Integer isDeleted;
}

注意：

• 上面使用isDeleted 属性来标准逻辑删除，就需要在表中添加这么一列，可以将未删除的状态设置为0，删除就对应的为1，
• 在进行查询时候，默认会添加 where is_deleted = 0 表示只查询未被删除的，
• 在逻辑删除的时候，默认会将 is_deleted 的值设置为1

6、条件构造器

6.1、条件构造器介绍

在使用mybatis-plus的时候，发现修改、删除、查询的都对应有Wrapper，他就是用于构建各种条件。是构造条件的顶级父类。

• Wrapper：条件构造器
  • AbstractWrapper：用于条件封装，生成sql的where条件
    • QueryWrapper：查询条件封装
    • UpdateWrapper：修改条件封装
    • AbstractLambdaWrapper：使用Lambda语法
      • LambdaQueryWrapper：用于Lambda语法使用的查询Wrapper
      • LambdaUpdateWrapper：Lambda更新封装Wrapper

6.2、QueryWrapper查询条件

    @Test
    public void testQueryWrapper(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 查询姓名中包含字母o，邮箱不为null，年龄大于等于20的
        wrapper.like("name","o")
                .isNotNull("email")
                .ge("age",20);
        
        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：SELECT id,name,age,email FROM user WHERE (name LIKE ? AND email IS NOT NULL AND age >= ?)

6.3、QueryWrapper排序条件

    @Test
    public void testQueryWrapper2(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 查询年龄在20到30之间的，先按照年龄降序，年龄相同在按照姓名升序
        wrapper.between("age",20,30)
                .orderByDesc("age")
                .orderByAsc("name");
        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：SELECT id,name,age,email FROM user WHERE (age BETWEEN ? AND ?) ORDER BY age DESC,name ASC

6.4、QueryWrapper删除条件

    @Test
    public void testQueryWrapper3(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 删除邮箱为空的数据
        wrapper.isNull("email");
        int i = this.userMapper.delete(wrapper);
        System.out.println(i);
    }

最终生成的sql：DELETE FROM user WHERE (email IS NULL)

6.5、QueryWrapper实现修改

    @Test
    public void testQueryWrapper4(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 修改name中包含字母a的数据
        wrapper.like("name","a");
        User user = new User();
        user.setAge(26);
        user.setEmail("bbb@qq.com");
        int i = this.userMapper.update(user, wrapper);
        System.out.println(i);
    }

最终生成的sql：UPDATE user SET age=?, email=? WHERE (name LIKE ?)

6.6、QueryWrapper查询指定的列

    @Test
    public void testQueryWrapper5(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 查询name、age两列数据
        wrapper.select("name","age");
        List<Map<String, Object>> maps = this.userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

最终生成的sql：SELECT name,age FROM user

6.7、QueryWrapper更改查询的条件优先级

默认情况下，使用QueryWrapper进行条件组装的时候，多个条件之间使用的and进行连接，QueryWrapper中提供and和or方法，可以提供指定的查询条件的优先级。

    @Test
    public void testQueryWrapper6(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 查询年龄在20到30之间并且(姓名包含字母a或者邮箱不为null的数据)
        wrapper.between("age",20,30)
                .and(i->i.like("name","a").or().isNotNull("email"));
        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：

SELECT id,name,age,email FROM user WHERE (age BETWEEN ? AND ? AND (name LIKE ? OR email IS NOT NULL))

6.8、QueryWrapper实现子查询

    @Test
    public void testQueryWrapper7(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 查询年龄在20到30之间的所有数据，这里故意采用子查询的方式完成
        wrapper.inSql("age","select age from user where age >= 20 and age <= 30");

        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：

SELECT id,name,age,email FROM user WHERE (age IN (select age from user where age >= 20 and age <= 30))

6.9、使用UpdateWrapper实现修改

虽然QueryWrapper可以完成修改操作的，但是需要传递实体对象，还是有点小麻烦。提供的UpdateWrapper是专门用于完成修改条件和数据封装

    @Test
    public void testUpdateWrapper(){
        // 创建UpdateWrapper对象，用于构建查询条件
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        // 修改name中包含字母a的数据
        // 设置修改的的条件
        wrapper.like("name","a");
        // 设置需要修改的数据
        wrapper.set("age",22).set("email","abc@qq.com");
        int i = this.userMapper.update(null, wrapper);
        System.out.println(i);
    }

最终生成的sql：

UPDATE user SET age=?,email=? WHERE (name LIKE ?)

6.10、使用condition组装条件

condition用于在进行条件封装的时候，判断某个值，当这个值不为null的时候，会自动添加对应的条件，如果为null，就不会添加条件

简单说：condition可以动态根据条件组装条件

    @Test
    public void testQueryWrapper9(){
        // 创建QueryWrapper对象，用于构建查询条件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 根据指定的数据，添加查询条件，模拟多条件查询的场景
        String name = "a";
        Integer age = 20;
        String email = null;
        wrapper.like(StringUtils.isNotBlank(name),"name",name)
                .gt(age!=null , "age",age)
                .eq(StringUtils.isNotBlank(email),"email",email);
        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：生成的sql中并不包含email，因为email为null

SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age > ?)

6.11、LambdaQueryWrapper

Lambda相关的查询与修改构造器，针对QueryWrapper和UpdateWrapper在构造添加的时候，需要书写表的列名进行优化，通过Lambda相关的条件构造器，可以将对应的条件采用实体类的实型进行编写。

    @Test
    public void testQueryWrapper10(){
        // 创建QueryWrapper对象，用于构建查询条件
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        // 查询姓名中包含字母o，邮箱不为null，年龄大于等于20的
        wrapper.like(User::getName,"o")
                .isNotNull(User::getEmail)
                .ge(User::getAge,20);
        List<User> users = this.userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

最终生成的sql：生成的sql中并不包含email，因为email为null

SELECT id,name,age,email FROM user WHERE (name LIKE ? AND email IS NOT NULL AND age >= ?)

6.12、LambdaUpdateWrapper

    @Test
    public void testUpdateWrapper(){
        // 创建UpdateWrapper对象，用于构建查询条件
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        // 修改name中包含字母a的数据
        // 设置修改的的条件
        wrapper.like(User::getName,"a");
        // 设置需要修改的数据
        wrapper.set(User::getAge,22).set(User::getEmail,"abc@qq.com");
        int i = this.userMapper.update(null, wrapper);
        System.out.println(i);
    }

最终生成的sql：生成的sql中并不包含email，因为email为null

UPDATE user SET age=?,email=? WHERE (name LIKE ?)

7、MyBatis-Plus分页

7.1、分页插件的配置和使用

MyBatis-Plus的分页非常简单，只需要添加一个配置类即可，而MyBatis-Plus提供的配置是以插件的方式提供。

@Configuration
public class MyBatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        // 创建拦截器对象
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 设置分页的拦截器,并设置数据库类型为mysql
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 返回拦截器对象
        return interceptor;
    }
}

通过上面代码的配置，就可以使用分页功能

    @Test
    public void testPagination(){
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.ge(User::getAge,20);
        Page<User> page = new Page<>(1,3);
        // 如果没有条件，第二个参数可以设置为null
        this.userMapper.selectPage(page , wrapper);
        // 查询的结果就放在Page对象中
        // 获取当前分页总页数
        System.out.println(page.getPages());
        // 每页显示条数，默认 10
        System.out.println(page.getSize());
        // 当前页
        System.out.println(page.getCurrent());
        // 当前满足条件的总数
        System.out.println(page.getTotal());
        // 分页查询的数据
        System.out.println(page.getRecords());
    }

7.2、自定义分页功能

在实际使用中，难免会出现需要自己书写sql语句，同时还需要使用分页功能，这时就需要自定义分页功能

需要注意：

• 自定义Mapper接口中的方法的第一个参数必须是MybatisPlus提供的分页Page对象。
• 自定义Mapper接口中的方法返回值必须是Page对象

public interface UserMapper extends BaseMapper<User> {
    @Select("select * from user where age > #{age}")
    public Page<User> selectUserAndPage(@Param("page") Page<User> page , @Param("age") Integer age);
}

    @Test
    public void testPagination2(){
        Page<User> page = new Page<>(1,3);
        // 如果没有条件，第二个参数可以设置为null
        this.userMapper.selectUserAndPage(page , 20);
        // 查询的结果就放在Page对象中
        // 获取当前分页总页数
        System.out.println(page.getPages());
        // 每页显示条数，默认 10
        System.out.println(page.getSize());
        // 当前页
        System.out.println(page.getCurrent());
        // 当前满足条件的总数
        System.out.println(page.getTotal());
        // 分页查询的数据
        System.out.println(page.getRecords());
    }

7.3、乐观锁与悲观锁

MySQL中的乐观锁和悲观锁主要区别如下:

1. 悲观锁:

• 悲观锁会在更新数据时对数据加锁,避免其他事务对此数据进行更新。
• 通常使用锁定的SELECT…FOR UPDATE语句来实现。
• 在整个更新操作过程中,数据被锁定,无法进行其他更新操作,保证数据consistency。
• 效率低,锁定时间长,发生锁争用的概率大。

1. 乐观锁:

• 乐观锁不会对数据加锁,只在更新时检查版本号,如果版本号不同,则说明数据已经被更新。
• 通常使用数据版本号version来实现。
• 在更新时,通过where 条件检查version号是否与最新的相同。如果不同就代表已经更新过了。
• 效率高,不会发生死锁。

InnoDB存储引擎从MySQL 5.5开始支持行锁,可以实现行级别的悲观锁。

总体来说,乐观锁适用于写比较少的场景,可以提高吞吐量。悲观锁适用于写比较多的场景,可以保证数据的完整性。

7.4、mybatis-plus的乐观锁插件

为了测试，重新创建一张表

CREATE TABLE goods(
  id INT PRIMARY KEY AUTO_INCREMENT,
  NAME VARCHAR(100),
  price DOUBLE ,
  num INT,
  VERSION INT DEFAULT 0
);
INSERT INTO goods(id,NAME,price,num,VERSION) VALUES(NULL,"华为手机",100,3,0);

需要在数据库表中添加一列version，用于乐观锁的版本号确认，需要在实体类中使用@Version注解。

@Data
@TableName("goods")
public class Goods {
    @TableId
    private Long id;
    private String name;
    private Integer price;
    private Integer num;
    @Version
    private Integer version;
}

需要在拦截器中添加乐观锁的插件

@Configuration
public class MyBatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        // 创建拦截器对象
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 设置分页的拦截器,并设置数据库类型为mysql
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        // 添加乐观锁的拦截器
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        // 返回拦截器对象
        return interceptor;
    }
}

@SpringBootTest
public class GoodsTest {
    @Autowired
    private GoodsMapper goodsMapper;

    @Test
    public void test(){
        // 架设一个操作：需要对商品的价格先增加50%，然后在优惠20%
        // 架设另一个操作：需要对商品的价格在前一个修改后的基础上在优惠10%
        // 但是可能会出现两个操作同时进行的情况，就需要通过乐观锁进行控制
        // 架设两个操作同时进行，操作之前需要先查询到当前商品的数据信息
        Goods goods = this.goodsMapper.selectById(1);
        Goods goods2 = this.goodsMapper.selectById(1);

        // 开始执行 价格先增加50%
        goods.setPrice(goods.getPrice()*1.5);
        // 然后在优惠20%
        goods.setPrice(goods.getPrice()*0.8);
        // 将数据跟新到数据库
        int i = this.goodsMapper.updateById(goods);
        System.out.println(i);

        // goods2进行更新
        goods2.setPrice(goods2.getPrice()*0.9);
        // goods2更新不会成功
        this.goodsMapper.updateById(goods2);
        
        // 若要更新成功，就必须在更新失败后，重新获取数据，对最新的数据进行更新
    }
}

通过执行的过程中产生的sql语句，会发现，version作为where的条件存在

UPDATE goods SET name=?, price=?, num=?, version=? WHERE id=? AND version=?

8、代码生成器

MybatisX 是一款基于 IDEA 的快速开发插件，为效率而生。

安装：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装。安装成功会提示重启idea，我们重庆idea之后，就可以使用MybatisX插件了

使用前提：需要配置数据库源

选择 + 按钮，然后选择Data Source 菜单，找到 MySql 选项

在弹出窗口中，填写对应的信息，最后点击OK ，即可完成数据源的配置

打开数据源，找到对应的表，右击选择MyBatisX-Generator

需要根据提示，填写对应的内容

继续完成对应的配置

最后选择Finish ，即可生成最基础的模版，然后就可以开始愉快的编程了。

在mybatis-plus默认的功能不够的时候，就可以借助MyBaitsX快速给Mapper接口添加对应的方法，同时也会在mapper文件中生成对应的sql 语句。