Mybatis-plus学习笔记

一、入门案例

1.1 初始化项目

1.创建新项目

image-20220703160345161

image-20220703160636682

2.导入需要的依赖

<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.2</version>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!--mysql驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.29</version>
    <scope>runtime</scope>
</dependency>
<!--druid数据源-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.11</version>
</dependency>

3.编写配置文件

首先把项目中的resources目录下的application.properties文件重命名为application.yaml（可选，看自己对配置文件格式的喜好）

然后在application.yaml文件中进行如下配置

spring:
  # 配置数据源
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    username: root
    password: root

mybatis-plus:
  # mybatis-plus日志配置
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # mybatis-plus映射文件位置配置，即当我们需要写较复杂的sql语句时需要在resouces目录下的xxMapper.xml中进行，这个配置就是指定其位置
  mapper-locations: classpath*:/mapper/**/*.xml

简要介绍：

1、type：指定数据源的类型，这里我们使用的是阿里巴巴的druid数据源

2、驱动类driver-class-name：
spring boot 2.0（内置jdbc5驱动），驱动类使用->driver-class-name: com.mysql.jdbc.Driver
spring boot 2.1及以上（内置jdbc8驱动），驱动类使用->driver-class-name: com.mysql.cj.jdbc.Driver
否则运行测试用例的时候会有 WARN 信息

3、连接地址url
MySQL5.7版本的url：jdbc:mysql://localhost:3306/mybatisplus?characterEncoding=utf-8&useSSL=false
MySQL8.0版本的url：jdbc:mysql://localhost:3306/mybatisplus?serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false
否则运行测试用例报告如下错误：
java.sql.SQLException: The server time zone value ‘Öйú±ê׼ʱ¼ä’ is unrecognized or represents more

1.2 创建数据库

1.创建数据库和表

CREATE DATABASE `mybatis_plus`
use `mybatis_plus`;
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 '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.导入测试数据

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');

1.3 构建项目结构

1.新建包、实体类和mapper接口

（1）在项目中新建包entity和mapper，分别用于存放实体类和mapper接口类

（2）在entity包中新建一个类为``User`，如下

//以下三个注解皆是lombok插件中的，这样我们就可以不用自己生成getter、setter、toString等方法
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

通过点击左下角的Structure即可查看该User类的结构

image-20220703163818969

（3）在mapper包下新建一个接口类为``UserMapper，使其继承BaseMapper`

//BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的实体类型
//当继承了BaseMapper，我们就可以使用该mapper接口对象实现对单表的基本CRUD操作
public interface UserMapper extends BaseMapper<User> {
}

2.配置启动类

在SpringBoot工程的启动类即xxxApplication程序上方添加注解@MaperScan("mapper包的路径")，目的是指定mapper所在位置，让Spring容器在自动注入时能够扫描到mapper接口类，下方这个com.xk.mybatisplus.mapper就是刚刚我们创建的mapper包

image-20220703164124904

搭建好的结构如图所示：

image-20220703170536716

1.4 测试

在Test目录中可以新建一个测试类，编写好测试方式进行测试

@SpringBootTest
class MybatisPlusApplicationTests {
    //这儿它会爆红，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。为了避免报错，可以在mapper接口上添加 @Repository 注解
    @Autowired
    private UserMapper userMapper;

    @Test
    void testSelectList() {
        //selectList()方式是根据MP内置的条件构造器QueryWrapper查询一个list集合，null表示没有条件，即查询所有
        //然后遍历集合逐个打印
        userMapper.selectList(null).forEach(System.out::println);
    }
}

测试结果：

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

由于我们在配置文件中配置了mybatis-plus的日志打印功能，所以在控制台可以看见执行该测试程序动态生成的sql语句：

==>  Preparing: SELECT id,name,age,email FROM user
==> Parameters: 
<==    Columns: id, name, age, email
<==        Row: 1, Jone, 18, test1@baomidou.com
<==        Row: 2, Jack, 20, test2@baomidou.com
<==        Row: 3, Tom, 28, test3@baomidou.com
<==        Row: 4, Sandy, 21, test4@baomidou.com
<==        Row: 5, Billie, 24, test5@baomidou.com
<==      Total: 5

二、基本CRUD

2.1 BaseMapper方法使用介绍

public interface BaseMapper<T> extends Mapper<T> {
    /**
    * 插入一条记录
    * @param entity 实体对象
    */
    int insert(T entity);
    /**
    * 根据 ID 删除
    * @param id 主键ID
    */
    int deleteById(Serializable id);
    /**
    * 根据实体(ID)删除
    * @param entity 实体对象
    * @since 3.4.4
    */
    int deleteById(T entity);
    /**
    * 根据 columnMap 条件，删除记录
    * @param columnMap 表字段 map 对象
    */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    /**
    * 根据 entity 条件，删除记录
    * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where语句）
    */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 删除（根据ID 批量删除）
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    /**
    * 根据 ID 修改
    * @param entity 实体对象
    */
    int updateById(@Param(Constants.ENTITY) T entity);
    /**
    * 根据 whereEntity 条件，更新记录
    * @param entity 实体对象 (set 条件值,可以为 null)
    * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成where 语句）
    */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
    /**
    * 根据 ID 查询
    * @param id 主键ID
    */
    T selectById(Serializable id);
    /**
    * 查询（根据ID 批量查询）
    * @param idList 主键ID列表(不能为 null 以及 empty)
    */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
    /**
    * 查询（根据 columnMap 条件）
    * @param columnMap 表字段 map 对象
    */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
    /**
    * 根据 entity 条件，查询一条记录
    * 查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
            if (ts.size() != 1) {
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
            }else{
                return ts.get(0);
            }
        }else{
            return null;
        }
    }
    /**
    * 根据 Wrapper 条件，查询记录数是否存在
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    default boolean exists(Wrapper<T> queryWrapper) {
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0L;
    }
    /**
    * 根据 Wrapper 条件，查询总记录数
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 根据 entity 条件，查询全部记录
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 根据 Wrapper 条件，查询全部记录
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 根据 Wrapper 条件，查询全部记录
    * 注意： 只返回第一个字段的值
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 根据 entity 条件，查询全部记录（并翻页）
    * @param page 分页查询条件（可以为 RowBounds.DEFAULT）
    * @param queryWrapper 实体对象封装操作类（可以为 null）
    */
    <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    /**
    * 根据 Wrapper 条件，查询全部记录（并翻页）
    * @param page 分页查询条件
    * @param queryWrapper 实体对象封装操作类
    */
    <P extends IPage<Map<String, Object>>> P selectMapsPage(P page,@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

通过以上方式，我们可以更快的对单表数据进行操作，并且无需自己写一句sql

2.2 插入

在刚刚入门案例搭建好的项目结构基础上，我们在测试类中编写测试代码对CRUD进行测试

@Test
void testInsert(){
    User user = new User(null, "张三", 23, "zhangsan@qq.com");
    //insert方法等价于INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    //插入成功后Mybatis-Plus会返回受影响行数，并将该对象插入后的对应数据的id赋值到对象上
    int result = userMapper.insert(user);
    //result = 1
    System.out.println("受影响行数：" + result);
    //id=1543529939734368257，这是MyBatis-Plus在实现数据插入时，默认基于雪花算法策略生成的id，所以我们在数据库中的id字段类型设置为了bigint，当然，我们也可以不使用这种方式生成id，而是在对象的id属性上加上@TableId注解将id的生成方式设置为自增，这个就后面再说明
    System.out.println("id自动获取：" + user.getId());
}

执行完后在数据库user表中进行查看，可发现新增的记录

2.3 删除

2.3.1 通过id删除

@Test
void testDelete(){
    //通过id删除用户信息
    //DELETE FROM user WHERE id=?
    int result = userMapper.deleteById(1543529939734368257L);
    System.out.println("受影响行数：" + result); //1
}

执行后，id为1543529939734368257的数据被删除

2.3.2 通过id批量删除

@Test
void testDelete(){
    //通过多个id批量删除
    //DELETE FROM user WHERE id IN ( ? , ? , ? )
    List<Long> idList = Arrays.asList(1L, 2L, 3L);
    int result = userMapper.deleteBatchIds(idList);
    System.out.println("受影响行数：" + result); //1
}

执行后，id为1、2、3的数据被删除

2.3.3 通过map条件集合删除

@Test
void testDelete(){
    //根据map集合中所设置的条件删除记录
    //DELETE FROM user WHERE name = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("name", "Sandy");
    map.put("age", 21);
    int result = userMapper.deleteByMap(map);
    System.out.println("受影响行数：" + result); //1
}

执行后，name为Sandy且age为21的数据被删除

从2.1可知，BaseMapper还提供了通过条件构造器的方式进行删除、修改、查询的方法，这些方法的测试就留到条件构造器讲解部分再进行

为了后续测试，我们重新添加一些数据到数据表中

2.4 修改

@Test
void testUpdate(){
    User user = new User(4L, "admin", 22, null);
    //UPDATE user SET name=?, age=? WHERE id=?
    int result = userMapper.updateById(user);
    System.out.println("受影响行数：" + result); //1
}

方法执行后，id为4的数据的name、age字段值会被修改为admin和22，而没有被设置的email则不变

2.5 查询

2.5.1 通过id查询

@Test
void testSelect(){
    //根据id查询用户信息
    //SELECT id,name,age,email FROM user WHERE id=?
    User user = userMapper.selectById(4L);
    System.out.println(user);//User(id=4, name=admin, age=22, email=test4@baomidou.com)
}

2.5.2 通过id批量查询

@Test
void testSelect(){
    //根据多个id查询多个用户信息
    //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
    List<Long> idList = Arrays.asList(4L, 5L);
    List<User> list = userMapper.selectBatchIds(idList);
    list.forEach(System.out::println);
    //User(id=4, name=admin, age=22, email=test4@baomidou.com)
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com)
}

2.5.3 通过map条件集合查询

@Test
void testSelect(){
    //通过map条件查询用户信息
    //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("age", 22);
    map.put("name", "admin");
    List<User> list = userMapper.selectByMap(map);
    list.forEach(System.out::println);//User(id=4, name=admin, age=22, email=test4@baomidou.com)
}

2.5.4 查询所有数据

@Test
void testSelect(){
    //查询所有用户信息
    //SELECT id,name,age,email FROM user
    List<User> list = userMapper.selectList(null);//查询条件构造器为null，说明没有条件，则查询所有数据
    list.forEach(System.out::println);
    //User(id=1, name=Jone, age=18, email=test1@baomidou.com)
    //User(id=2, name=Jack, age=20, email=test2@baomidou.com)
    //User(id=3, name=Tom, age=28, email=test3@baomidou.com)
    //User(id=4, name=admin, age=22, email=test4@baomidou.com)
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com)
}

2.6 自定义SQL

首先，在UserMaper接口中自定义一个方法

@Repository
public interface UserMapper extends BaseMapper<User> {
    Map<String,Object> selectMapById(Long id);
}

然后，在resources目录下创建一个mapper目录，再在里面创建一个UserMapper.xml文件（注意：应该提前在yaml配置文件中配置好mapper-locations，否则会找不到该映射文件，这里在前面也已经提到过且配置好的）

然后，在UserMapper中添加如下代码：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xk.mybatisplus.mapper.UserMapper">

    <!--Map<String,Object> selectMapById(Long id);-->
    <select id="selectMapById" resultType="map">
        select id,name,age,email from user where id = #{id}
    </select>
</mapper>

最后，测试

@Test
void testCustom(){
    Map<String, Object> map = userMapper.selectMapById(2L);
    System.out.println(map);//{name=Jack, id=2, age=20, email=test2@baomidou.com}
}

这儿其实就是Mybatis的内容，但是我们不用再像Mybtis中那样每次使用XXMapper前都需要先通过SqlSession获取mapper对象

2.7 通用Service

Mybatis-plus将通用的service CRUD方法封装成了一个IService接口

说明：

通用 Service CRUD 被封装IService接口，进一步封装 CRUD 采用save saveOrUpdate get remove update list page count chain前缀命名的方式与 Mapper 层进行区分，避免混淆

在方法条件中，泛型 T 为任意实体对象，对象 Wrapper 为条件构造器

建议：如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类

通用Service接口和类中的方法可自行通过源码查询

这里通过查看Mybatis-plus的``IService接口和ServiceImpl`类源码关系可以知晓对于我们自定义的Service层接口和类应该怎样使用框架提供的通用方法

//IService接口
public interface IService<T>{...}

//ServiceImpl类
public class ServiceImpl<M extends BaseMapper<T>, T> implements IService<T> {...}

2.7.1 如何使用通用Service

1.创建Service接口

//让自定义service继承IService，即可拥有IService中已定义的CRUD通用方法
public interface UserService extends IService<User> {
}

2.创建ServiceImpl

//让自定义的service接口实现类实现自定义的service接口，并且继承已定义的ServiceImpl通用实现类，那么此时自定义的service接口实现类既能去实现且拥有自定义service接口中的方法，又能拥有ServiceImpl中已经实现的service层通用方法
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

当UserService中我们没有定义任何新的方法时，UserServiceImpl这样写并不会报错，因为尽管在UserServiceImpl里面并没有去实现接口UserService继承的IService中任何的方法，但是它继承的ServiceImpl实现了IService的方法，等价于它自身也就实现了IService中的方法

通过上方ServiceImpl的源码可知，我们自定义的service实现类要想继承ServiceImpl，不仅需要提供该service要操作的实体类对象，还要提供实体类对象对应的mapper接口对象

3.测试查询记录数

@Test
void testCountService(){
    long count = userService.count();
    System.out.println("总记录数：" + count);//总记录数：5
}

4.测试批量插入

@Test
void testSaveBatch(){
    // SQL长度有限制，海量数据插入单条SQL无法实行
    // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
    // 而在通用Service中是将所有数据通过循环遍历插入实现
    ArrayList<User> users = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        User user = new User();
        user.setName("ybc" + i);
        user.setAge(20 + i);
        users.add(user);
    }
    //SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? )
    userService.saveBatch(users);
}

三、常用注解

3.1 @TableName

在之前的测试中，我们并没有指定需要操作的数据库表，但Mybatis-plus仍然能准确地自动操作对应表，这是因为在自定义Mapper接口继承BaseMapper时设置了BaseMapper的泛型对象为User，Mybatis-plus就会根据这个实体对象类型在数据库中找到对应的user表（此过程中默认实体对象类型的类名和表名一致，不区分大小写），由此可知，Mybatis-plus在操作表时，是由BaseMapper的泛型决定的

当我们将user表修改为t_user而User对象类型名不变时，再去对数据表进行操作就会出现找不到对应表的错误

image-20220704142801176

此时，我们有两种方法可以解决：

3.1.1 使用@TableName

当我们的实体类对象类名和表名不一致时，可以使用@TableName指定，例如：

@TableName("t_user")//里面的字符串就是数据库中对应表的表名
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

3.1.2 全局配置

我们还可以在application.yaml文件中对表名的前缀进行全局配置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:/mapper/**/*.xml
  global-config:
    db-config:
      # 配置MyBatis-Plus操作表的默认前缀
      table-prefix: t_

3.2 @TableId

3.2.1 场景一

在Mybatis-plus中默认将id作为数据表的主键，如果我们将数据表中id修改为uid，User对象的属性也修改为对应的uid，此时当我们的数据操作中涉及到对象uid，Mybatis-plus会报以下错误，说明MyBatis-plus没有将uid作为主键赋值

image-20220704143952381

解决的方法就是在实体类是对象User的属性uid上加上``@TableId`，表明将uid作为主键

@TableName("t_user")
public class User {
    @TableId
    private Long uid;
    private String name;
    private Integer age;
    private String email;
}

3.2.2 场景二

如果在实体类对象中我们的主键属性名为id，而在数据库表中主键字段名为uid，此时当我们的数据操作中涉及到对象主键id，Mybatis-plus会报以下错误，说明我们实体类对象的主键id没有和数据库表中的主键uid对应

image-20220704144912934

解决方法是通过@TableId的value属性，为实体类对象的主键id指定其在数据库表中的映射名

@TableName("t_user")
public class User {
    @TableId(value = "uid")  //@TableId("uid")
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

3.2.3 场景三

通过前面的讲解我们可以知道，Mybatis-plus对于主键id的生成方式默认为基于雪花算法的策略生成，但是我们通常很多情况是基于数据库的自增策略生成，所以，要完成这个需求，我们需要将@TableId的type属性设置为IdType.AUTO

@TableName("t_user")
public class User {
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

同样，我们也可以像前面配置数据库表名前缀的方式一样，通过配置文件进行全局配置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:/mapper/**/*.xml
  global-config:
    db-config:
      # 配置MyBatis-Plus操作表的默认前缀
      table-prefix: t_
      # 设置id生成策略为自增
      id-type: auto

Mybatis-plus对于id的生成策略方式有：

3.2.4 雪花算法

1.背景

需要选择合适的方案去应对数据规模的增长，以应对逐渐增长的访问压力和数据量

数据库的扩展方式主要包括：业务分库、主从复制，数据库分表

2.数据库分表

将不同业务数据分散存储到不同的数据库服务器，能够支撑百万甚至千万用户规模的业务，但如果业务继续发展，同一业务的单表数据也会达到单台数据库服务器的处理瓶颈。例如，淘宝的几亿用户数据，如果全部存放在一台数据库服务器的一张表中，肯定是无法满足性能要求的，此时就需要对单表数据进行拆分

单表数据拆分有两种方式：垂直分表和水平分表。示意图如下：

image-20220704151108950

(1)垂直分表

垂直分表适合将表中某些不常用且占了大量空间的列拆分出去

例如，前面示意图中的 nickname 和 description 字段，假设我们是一个婚恋网站，用户在筛选其他用户的时候，主要是用 age 和 sex 两个字段进行查询，而 nickname 和 description 两个字段主要用于展示，一般不会在业务查询中用到。description 本身又比较长，因此我们可以将这两个字段独立到另外一张表中，这样在查询 age 和 sex 时，就能带来一定的性能提升

(2)水平分表

水平分表适合表行数特别大的表，有的公司要求单表行数超过 5000 万就必须进行分表，这个数字可以作为参考，但并不是绝对标准，关键还是要看表的访问性能。对于一些比较复杂的表，可能超过 1000万就要分表了；而对于一些简单的表，即使存储数据超过 1 亿行，也可以不分表

但不管怎样，当看到表的数据量达到千万级别时，作为架构师就要警觉起来，因为这很可能是架构的性能瓶颈或者隐患

水平分表相比垂直分表，会引入更多的复杂性，例如要求全局唯一的数据id该如何处理，比如：

主键自增

①以最常见的用户 ID 为例，可以按照 1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，1000000 ~ 1999999 放到表2中，以此类推
②复杂点：分段大小的选取。分段太小会导致切分后子表数量过多，增加维护复杂度；分段太大可能会导致单表依然存在性能问题，一般建议分段大小在 100 万至 2000 万之间，具体需要根据业务选取合适的分段大小
③优点：可以随着数据的增加平滑地扩充新的表。例如，现在的用户是 100 万，如果增加到 1000 万，只需要增加新的表就可以了，原有的数据不需要动
④缺点：分布不均匀。假如按照 1000 万来进行分表，有可能某个分段实际存储的数据量只有 1 条，而另外一个分段实际存储的数据量有 1000 万条

取模

①同样以用户 ID 为例，假如我们一开始就规划了 10 个数据库表，可以简单地用 user_id % 10 的值来表示数据所属的数据库表编号，ID 为 985 的用户放到编号为 5 的子表中，ID 为 10086 的用户放到编号为 6 的子表中
②复杂点：初始表数量的确定。表数量太多维护比较麻烦，表数量太少又可能导致单表性能存在问题
③优点：表分布比较均匀
④缺点：扩充新的表很麻烦，所有数据都要重分布

雪花算法

雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的主键的有序性
①核心思想：长度共64bit（一个long型）。首先是一个符号位，1bit标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0。41bit时间截(毫秒级)，存储的是时间截的差值（当前时间截 - 开始时间截)，结果约等于69.73年。10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID，可以部署在1024个节点）。12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID）

image-20220704151850833

②优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，并且效率较高

3.3 @TableField

这个注解的使用和作用与@TableId相似，只不过这个是针对于普通属性和字段之间关系的注解

当我们的实体类对象的属性名与数据库表中的字段名不一致时，可以通过这个注解实现同步

比如，我们在数据库表user中的字段名为username，而在实体类对象User的属性名为name，此时使用@TableField注解的value属性：

@TableName("t_user")
public class User {
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    @TableField(value = "username") //如果数据库表中的字段名为下划线的格式也可以使用这种方法
    private String name;
    private Integer age;
    private String email;
}

当我们在一个实体类对象中，其属性值可能还包含了其它类型的对象，但是它又不属于当前对象的一个数据库字段，此时我们可以使用@TableField的exist属性类排除这个对象属性，比如：

@TableName("t_user")
public class User {
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableField(exist = false)
    private List<Course> courseList;
}

3.4 @TableLogic

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
使用场景：可以进行数据恢复

首先，在表中加上一个标志逻辑删除的字段，数据类型设为int，默认值为0，表示默认为未删除

然后，在对应的实体类对象中加上该属性，并在属性上方加上@TableLogic注解，作为逻辑删除的标识属性

@TableName("t_user")
public class User {
    @TableId(value = "uid",type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
    @TableLogic
    private Integer isDelete;
}

此时，我们去测试删除几条数据

@Test
void testDelete(){
    //通过多个id批量删除
    //DELETE FROM user WHERE id IN ( ? , ? , ? )
    List<Long> idList = Arrays.asList(1L, 2L, 3L);
    int result = userMapper.deleteBatchIds(idList);
    System.out.println("受影响行数：" + result);
}
//==>  Preparing: UPDATE t_user SET is_delete=1 WHERE uid IN ( ? , ? , ? ) AND is_delete=0
//==> Parameters: 1(Long), 2(Long), 3(Long)
//<==    Updates: 3
//Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@13234ac9]
//受影响行数：3
//通过控制台日志打印可以发现，删除实质上变成了修改，而此时再去数据库中查看可发现id为1、2、3的数据并没有被删除，而是id_delete字段的值被设为了1

此时，我们再查询所有数据

@Test
void testSelect(){
    //查询所有用户信息
    //SELECT id,name,age,email FROM user
    List<User> list = userMapper.selectList(null);
    list.forEach(System.out::println);
    //User(id=4, name=admin, age=22, email=test4@baomidou.com, isDelete=0)
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com, isDelete=0)
    //User(id=1543595258846908417, name=ybc0, age=20, email=null, isDelete=0)
    //User(id=1543595259274727425, name=ybc1, age=21, email=null, isDelete=0)
    //User(id=1543595259274727426, name=ybc2, age=22, email=null, isDelete=0)
    //User(id=1543595259274727427, name=ybc3, age=23, email=null, isDelete=0)
    //User(id=1543595259274727428, name=ybc4, age=24, email=null, isDelete=0)
    //User(id=1543848119749087234, name=张三, age=23, email=zhangsan@qq.com, isDelete=0)
}
//==>  Preparing: SELECT uid AS id,name,age,email,is_delete FROM t_user WHERE is_delete=0
//==> Parameters: 
//<==    Columns: id, name, age, email, is_delete
//<==        Row: 4, admin, 22, test4@baomidou.com, 0
//<==        Row: 5, Billie, 24, test5@baomidou.com, 0
//<==        Row: 1543595258846908417, ybc0, 20, null, 0
//<==        Row: 1543595259274727425, ybc1, 21, null, 0
//<==        Row: 1543595259274727426, ybc2, 22, null, 0
//<==        Row: 1543595259274727427, ybc3, 23, null, 0
//<==        Row: 1543595259274727428, ybc4, 24, null, 0
//<==        Row: 1543848119749087234, 张三, 23, zhangsan@qq.com, 0
//<==      Total: 8

可以发现，查询出来的数据中字段is_delete都为0，刚刚被逻辑删除的几条数据则没有查询出来，但实际上他们并没有被删除，只是is_delete字段值为1

Mybatis-plus还提供了很多注解，这里只是常用的部分，其余详细内容需要到官方文档去查看

四、条件构造器

4.1 Wrapper介绍

Wrapper ： 条件构造抽象类，最顶端父类

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

Wrapper结构图：

image-20220704160530615

4.2 QueryWrapper

通过QueryWrapper条件构造器我们可以对数据进行增删改查、排序、分组等操作

4.2.1 组装查询条件

@Autowired
private UserMapper userMapper;

@Test
void testQueryWrapper1(){
    //查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("name", "a")
        .between("age", 20, 30)
        .isNotNull("email");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println); //User(id=4, name=admin, age=22, email=test4@baomidou.com, isDelete=0)
}

4.2.2 组装排序条件

@Test
void testQueryWrapper2(){
    //按年龄降序查询用户，如果年龄相同则按id升序排列
    //SELECT id,name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,id ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .orderByDesc("age")
        .orderByAsc("id");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com, isDelete=0)
    //User(id=1543595259274727428, name=ybc4, age=24, email=null, isDelete=0)
    //User(id=1543595259274727427, name=ybc3, age=23, email=null, isDelete=0)
    //User(id=1543848119749087234, name=张三, age=23, email=zhangsan@qq.com, isDelete=0)
    //User(id=4, name=admin, age=22, email=test4@baomidou.com, isDelete=0)
    //User(id=1543595259274727426, name=ybc2, age=22, email=null, isDelete=0)
    //User(id=1543595259274727425, name=ybc1, age=21, email=null, isDelete=0)
    //User(id=1543595258846908417, name=ybc0, age=20, email=null, isDelete=0)
}

4.2.3 组装删除条件

@Test
void testQueryWrapper3(){
    //删除email为空的用户
    //DELETE FROM t_user WHERE is_deleted=0 AND (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.isNull("email");
    //条件构造器也可以构建删除语句的条件
    int result = userMapper.delete(queryWrapper);
    System.out.println("受影响的行数：" + result);
}

4.2.4 组装修改条件

@Test
void testQueryWrapper4(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE is_deleted=0 AND (name LIKE ? AND age > ? OR email IS NULL)
    queryWrapper
        .like("name", "a")
        .gt("age", 20)
        .or()
        .isNull("email");
    User user = new User();
    user.setAge(18);
    user.setEmail("user@qq.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

4.2.5 条件优先级

@Test
void testQueryWrapper4(){
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
    //UPDATE t_user SET age=?, email=? WHERE is_deleted=0 AND (name LIKE ? AND (age > ? OR email IS NULL))
    //lambda表达式内的条件优先执行
    queryWrapper
        .like("name", "a")
        .and(i -> i.gt("age", 20).or().isNull("email"));//这儿使用lambda表达式让sql先执行(age > ? OR email IS NULL)再执行name LIKE ?
    User user = new User();
    user.setAge(18);
    user.setEmail("user@qq.com");
    int result = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数：" + result);
}

4.2.6 组装select子句

@Test
void testQueryWrapper5(){
    //查询用户信息的name和age字段
    //SELECT name,age FROM t_user WHERE is_delete=0
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("name", "age");
    //selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值为null
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
    //{name=admin, age=18}
    //{name=Billie, age=24}
    //{name=张三, age=23}
}

4.2.7 实现子查询

@Test
void testQueryWrapper6(){
    //查询id小于等于3的用户信息
    // SELECT uid,name,age,email,is_deleted FROM t_user WHERE is_delete=0 AND (uid IN (select uid from t_user where uid <= 3))
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.inSql("uid", "select uid from t_user where uid <= 3");
    List<User> list = userMapper.selectList(queryWrapper);
    list.forEach(System.out::println);
    //User(id=1, name=Jone, age=18, email=test1@baomidou.com, isDelete=0)
    //User(id=2, name=Jack, age=20, email=test2@baomidou.com, isDelete=0)
    //User(id=3, name=Tom, age=28, email=test3@baomidou.com, isDelete=0)
}

4.3 UpdateWrapper

@Test
void testUpdateWrapper(){
    //将（年龄大于20或邮箱为null）并且用户名中包含有a的用户信息将年龄修改为18，邮箱修改为user@qq.com
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    //lambda表达式内的条件优先执行
    //UPDATE t_user SET age=?,email=? WHERE is_delete = 0 AND (username LIKE ? AND (age > ? OR email IS NULL))
    //组装set子句以及修改条件
    updateWrapper
        .set("age", 18)
        .set("email", "user@qq.com")
        .like("name", "a")
        .and(i -> i.gt("age", 20).or().isNull("email"));
    //如果不需要使用实体类对象进行填充，update方法第一个参数可以设置为null
    int result = userMapper.update(null, updateWrapper);
    System.out.println(result);
}

4.4 Condition

在实际开发中，我们的查询条件或修改字段都需要先判断是否满足一定的条件后才会拼接到SQL中，比如判空，若不为空时才将条件添加到sql中，而这些条件应该如何处理？

4.4.1 方法一：逐个判断

@Test
void testCondition(){
    //定义查询条件，有可能为null
    String name = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
    if(StringUtils.isNotBlank(name)){
        queryWrapper.like("name","a");
    }
    if(ageBegin != null){
        queryWrapper.ge("age", ageBegin);
    }
    if(ageEnd != null){
        queryWrapper.le("age", ageEnd);
    }
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?)
    //因为name属性值为空，不满足条件，所以没有被拼接到sql中
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

4.4.2 方法二：使用带condition参数的重载方法

即使用条件构造器的方法时，需要满足一定条件才能拼接到sql中的查询条件或修改字段都使用方法参数中带有condition的重载方法，比如，like方法使用public Children like(boolean condition, R column, Object val)

@Test
void testCondition(){
    //定义查询条件，有可能为null
    String name = null;
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
    queryWrapper
        .like(StringUtils.isNotBlank(name),"name","a")
        .ge(ageBegin != null,"age",ageBegin)
        .le(ageEnd != null,"age",ageEnd);
    //SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >= ? AND age <= ?)
    //因为name属性值为空，不满足条件，所以没有被拼接到sql中
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

4.5 LambdaQueryWrapper

@Test
void testLambdaQueryWrapper(){
    //定义查询条件，有可能为null
    String name = "a";
    Integer ageBegin = 10;
    Integer ageEnd = 24;
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    //避免使用字符串表示数据库表字段，防止因写错造成运行时错误
    queryWrapper
        .like(StringUtils.isNotBlank(name), User::getName, name)
        .ge(ageBegin != null, User::getAge, ageBegin)
        .le(ageEnd != null, User::getAge, ageEnd);
    //SELECT uid AS id,name,age,email,is_delete FROM t_user WHERE is_delete=0 AND (name LIKE ? AND age >= ? AND age <= ?)
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

4.6 LambdaUpdateWrapper

@Test
void testLambdaUpdateWrapper(){
    //组装set子句
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
    //避免使用字符串表示数据库表字段，防止因写错造成运行时错误
    updateWrapper
        .set(User::getAge, 18)
        .set(User::getEmail, "user@qq.com")
        .like(User::getName, "a")
        .and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));
    //lambda表达式内的逻辑优先运算
    //UPDATE t_user SET age=?,email=? WHERE is_delete=0 AND (name LIKE ? AND (age < ? OR email IS NULL))
    int update = userMapper.update(null, updateWrapper);
    System.out.println(update);
}

五、插件

5.1 分页插件

5.1.1 分页插件的配置和使用

1.分页插件的配置

首先，新建一个包为config

然后新建一个Mybatis-plus的配置类MybatisPlusConfig

@Configuration
@MapperScan("com.xk.mybatisplus.mapper") //将之前在SpringBoot启动类上配置的扫描配置注解移动到这个配置类
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

2.分页插件的使用

@Test
void testPage(){
    //第一参数为当前页码，第二个参数为每页的数据量
    Page<User> page = new Page<>(2,3);
    //传入page对象和一个没有条件的条件构造器
    userMapper.selectPage(page, null);
    System.out.println(page);
    //User(id=4, name=admin, age=18, email=user@qq.com, isDelete=0)
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com, isDelete=0)
    //User(id=1543595258846908417, name=ybc0, age=20, email=null, isDelete=0)
    //过程中执行的sql语句
    //SELECT COUNT(*) AS total FROM t_user WHERE is_delete = 0
    //SELECT uid AS id,name,age,email,is_delete FROM t_user WHERE is_delete=0 LIMIT ?,?
}

image-20220704200539783

3.分页数据获取

@Test
void testPage(){
    //第一参数为当前页码，第二个参数为每页的数据量
    Page<User> page = new Page<>(2,3);
    //传入page对象和一个没有条件的条件构造器
    userMapper.selectPage(page, null);
    //获取分页数据
    List<User> list = page.getRecords();
    list.forEach(System.out::println);
    //User(id=4, name=admin, age=18, email=user@qq.com, isDelete=0)
    //User(id=5, name=Billie, age=24, email=test5@baomidou.com, isDelete=0)
    //User(id=1543595258846908417, name=ybc0, age=20, email=null, isDelete=0)
    System.out.println("当前页："+page.getCurrent());//当前页：2
    System.out.println("每页显示的条数："+page.getSize());//每页显示的条数：3
    System.out.println("总记录数："+page.getTotal());//总记录数：11
    System.out.println("总页数："+page.getPages());//总页数：4
    System.out.println("是否有上一页："+page.hasPrevious());//是否有上一页：true
    System.out.println("是否有下一页："+page.hasNext());//是否有下一页：true
}

5.2 xml自定义分页

通过上述例子可以知道，当我们需要对数据进行分页查询时，我们可以在selectPage方法中传入Mybatis-plus自带的分页插件对象和条件构造器，让查询条件拼接到sql语句中，然后再将符合条件的数据进行分页，但是如果我们需要查询的数据需要使用较复杂一些的sql或是多表联查，那么条件构造器将不能满足我们的使用要求，此时我们就可以自定义sql语句，然后将自定义sql语句查询出来的数据进行分页

这里举一个简单的例子，只是为了说明可以这样使用：

首先，在UserMapper中自定义一个方法

//当我们需要将自定义sql查询出来的数据进行分页时，查询的方法参数中必须将Page对象放在第一位，尽管我们在sql中并不使用它
Page<User> selectPaged(@Param("page") Page<User> page, @Param("age") Integer age);

然后，在UserMapper.xml文件中编写方法对应的sql语句

<!--Page<User> selectPaged(@Param("page") Page<User> page, @Param("age") Integer age);-->
<select id="selectPaged" resultType="com.xk.mybatisplus.entity.User">
    select uid,name,age,email,is_delete from t_user where is_delete = 0 and age > #{age}
</select>

测试：

@Test
void testCustomPage(){
    Page<User> page = new Page<>(2, 3);
    //将page分页对象和查询条件作为参数传入，当然，像这种简单的查询我们可以使用条件构造器代替这种自定义sql的方式
    userMapper.selectPaged(page,20);
    List<User> records = page.getRecords();
    records.forEach(System.out::println);
    //User(id=null, name=ybc2, age=22, email=null, isDelete=0)
    //User(id=null, name=ybc3, age=23, email=null, isDelete=0)
    //User(id=null, name=ybc4, age=24, email=null, isDelete=0)

    //==>  Preparing: SELECT COUNT(*) AS total FROM t_user WHERE is_delete = 0 AND age > ?
    //==> Parameters: 20(Integer)
    //<==    Columns: total
    //<==        Row: 7
    //<==      Total: 1
    //==>  Preparing: select uid,name,age,email,is_delete from t_user where is_delete = 0 and age > ? LIMIT ?,?
    //==> Parameters: 20(Integer), 3(Long), 3(Long)
    //<==    Columns: uid, name, age, email, is_delete
    //<==        Row: 1543595259274727426, ybc2, 22, null, 0
    //<==        Row: 1543595259274727427, ybc3, 23, null, 0
    //<==        Row: 1543595259274727428, ybc4, 24, null, 0
    //<==      Total: 3
}

5.3 乐观锁和悲观锁

5.3.1 介绍

场景：一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多

上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出的被修改后的价格，150元，这样他会将120元存入数据库

如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元

5.3.2 模拟冲突

首先，新建一个数据表，并插入一条数据

CREATE TABLE t_product
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
    price INT(11) DEFAULT 0 COMMENT '价格',
    VERSION INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
    PRIMARY KEY (id)
);
INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

然后，创建对应实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_product")
public class Product {
    @TableId(value = "id")
    private Long id;
    @TableField(value = "NAME")
    private String name;
    @TableField(value = "price")
    private Integer price;
    @TableField(value = "VERSION")
    private Integer version;
}

然后，新建mapper

@Repository
public interface ProductMapper extends BaseMapper<Product> {
}

测试：

@Autowired
private ProductMapper productMapper;
@Test
void tesOptimisticLock(){
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格：" + p1.getPrice());//小李取出的价格：100
    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格：" + p2.getPrice());//小王取出的价格：100
    //3、小李将价格加了50元，存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    productMapper.updateById(p1);
    System.out.println("小李修改后结果：" + productMapper.selectById(1L).getPrice());//小李修改后结果：150
    //4、小王将商品减了30元，存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    productMapper.updateById(p2);
    System.out.println("小王修改后结果：" + productMapper.selectById(1L).getPrice());//小王修改后结果：70
    //最后的结果
    Product p3 = productMapper.selectById(1L);
    //价格覆盖，最后的结果：70
    System.out.println("最后的结果：" + p3.getPrice());//最后的结果：70
}
//从以上测试可以发现，由于修改之前，小李和小王都获取最初的价格，而小王修改后将小李修改的价格覆盖了，导致最终的价格是小王在最初价格的基础上修改的，这就造成了冲突

5.3.3 乐观锁实现逻辑

在数据库表中添加version字段，作为数据的版本

取出记录时，连同version一起获取

SELECT id,`name`,price,`version` FROM product WHERE id=1

更新时将已修改的数据中version字段加1，并且在where条件中加上version=之前获取时的版本号

UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1 # 小李的sql
UPDATE product SET price=price-30, `version`=`version` + 1 WHERE id=1 AND `version`=1 # 小王的sql
# 当小王的sql执行时会发现已经找不到id=1且version=1的数据了，因为已经被小李修改为了version=2，这时小王的修改就不会成功，他必须重新获取一次数据再进行修改

5.3.4 Mybatis-plus实现乐观锁

1.@Version

给实体类中作为数据版本号的属性添加上@Version注解

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_product")
public class Product {
    @TableId(value = "id")
    private Long id;
    @TableField(value = "NAME")
    private String name;
    @TableField(value = "price")
    private Integer price;
    @TableField(value = "VERSION")
    @Version
    private Integer version;
}

2.配置乐观锁

@Configuration
@MapperScan("com.xk.mybatisplus.mapper")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //添加分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        //添加乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

3.测试

此时再将上方的测试方法运行一次

@Autowired
private ProductMapper productMapper;
@Test
void tesOptimisticLock(){
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格：" + p1.getPrice());//小李取出的价格：100
    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格：" + p2.getPrice());//小王取出的价格：100
    //3、小李将价格加了50元，存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    productMapper.updateById(p1);
    System.out.println("小李修改后结果：" + productMapper.selectById(1L).getPrice());//小李修改后结果：150
    //4、小王将商品减了30元，存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    productMapper.updateById(p2);
    System.out.println("小王修改后结果：" + productMapper.selectById(1L).getPrice());//小王修改后结果：150
    //最后的结果
    Product p3 = productMapper.selectById(1L);
    //小王修改失败，最后的结果：150
    System.out.println("最后的结果：" + p3.getPrice());//最后的结果：150
    
    //若小王还想修改，需要重新获取一次这条数据
    Product p4 = productMapper.selectById(1L);
    System.out.println("小王重新获取数据后的价格：" + p4.getPrice());//150
    p4.setPrice(p4.getPrice()  - 30);
    productMapper.updateById(p4);
    System.out.println("小王重新修改后结果：" + productMapper.selectById(1L).getPrice());//120
}

5.4 MybatisX插件

MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率。但是在真正开发过程中，MyBatis-Plus并不能为我们解决所有问题，例如一些复杂的SQL，多表联查，我们就需要自己去编写代码和SQL语句，我们该如何快速的解决这个问题呢，这个时候可以使用MyBatisX插件。MyBatisX一款基于 IDEA 的快速开发插件，为效率而生。

5.4.1 安装MybatisX

在IDEA中，点击File->settings

然后：

image-20220705133049646

安装完成后，若没有勾选则需要勾选表示启用，然后点击apply和ok

5.4.2 XML跳转

当我们在项目的java包下有实体类的mapper接口，resources包下有实体类的对应mapper接口的映射文件时，我们可以通过点击旁边的图标进行来回跳转

image-20220705135845344

5.4.3 代码生成

为了方便测试，可以新建一个项目进行

然后把之前项目中的部分依赖复制到新项目中

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.29</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.11</version>
</dependency>

然后，将application.yaml配置文件中的内容复制一份到新项目

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    username: root
    password: root

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:/mapper/**/*.xml

然后，在idea中配置数据源（必须）

image-20220705141308172

image-20220705141506313

配置成功后，就可以看到数据库和数据库中的表了

image-20220705141549137

然后，右键选择我们要生成代码的数据表，点击MybatisX-Generator

image-20220705141644268

在弹出的窗口中进行配置，可以根据自己需要进行配置，然后点击next

image-20220705142706912

在下一个页面进行详细配置，然后点finish

image-20220705143227503

然后即可看见MybatisX自动生成的对应controller、service、mapper及实体类

5.4.4 快速生成CRUD

当我们在mapper接口中对一个增删改查的方法进行编写时，只需要将方法名命名成见名知意的效果（在这个过程中MybatisX还会提示我们），然后按快捷键Alt + Enter，点击[MybatisX] Generate Mybatis Sql选项，MybatisX将会为我们自动生成方法以及对应的映射sql语句

image-20220705144826767

当方法旁边出现mybatis的图标时，就说明它已经为我们生成好了sql语句

image-20220705145144512

我们点击图标即可跳转到对应映射方法处

image-20220705145235897

例子：

public interface UserMapper extends BaseMapper<User> {

    List<User> selectAgeAndNameByAgeBetween(@Param("beginAge") Integer beginAge, @Param("endAge") Integer endAge);

    List<User> selectAllOrderByAgeDesc();

    int insertSelective(User user);

    int updateAgeAndNameByUid(@Param("age") Integer age, @Param("name") String name, @Param("uid") Long uid);

    int deleteByUidAndName(@Param("uid") Long uid, @Param("name") String name);
}

<select id="selectAgeAndNameByAgeBetween" resultMap="BaseResultMap">
    select age, name
    from t_user
    where age between #{beginAge,jdbcType=INTEGER} and #{endAge,jdbcType=INTEGER}
</select>
<select id="selectAllOrderByAgeDesc" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List"/>
    from t_user
    order by age desc
</select>
<insert id="insertSelective">
    insert into t_user
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="uid != null">uid,</if>
        <if test="name != null">name,</if>
        <if test="age != null">age,</if>
        <if test="email != null">email,</if>
        <if test="isDelete != null">is_delete,</if>
        <if test="gender != null">gender,</if>
    </trim>
    values
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="uid != null">#{uid,jdbcType=BIGINT},</if>
        <if test="name != null">#{name,jdbcType=VARCHAR},</if>
        <if test="age != null">#{age,jdbcType=INTEGER},</if>
        <if test="email != null">#{email,jdbcType=VARCHAR},</if>
        <if test="isDelete != null">#{isDelete,jdbcType=INTEGER},</if>
        <if test="gender != null">#{gender,jdbcType=INTEGER},</if>
    </trim>
</insert>
<update id="updateAgeAndNameByUid">
    update t_user
    set age  = #{age,jdbcType=NUMERIC},
    name = #{name,jdbcType=VARCHAR}
    where uid = #{uid,jdbcType=NUMERIC}
</update>
<delete id="deleteByUidAndName">
    delete
    from t_user
    where uid = #{uid,jdbcType=NUMERIC}
    AND name = #{name,jdbcType=VARCHAR}
</delete>

六、通用枚举

在实际开发中，数据的有些字段值是固定的，例如性别（男或女），此时我们可以使用MyBatis-Plus的通用枚举来实现

首先，在t_user表中加上gender字段，代表性别

alter table t_user add gender int null;

然后，在实体类中添加对应属性

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User {
    @TableId(value = "uid")
    private Long id;
    private String name;
    private Integer age;
    private String email;
    //添加对应属性，类型为一会我们需要自定义的枚举类型
    private GenderEnum gender;
    @TableLogic
    private Integer isDelete;
}

然后，新建一个自定义枚举，并在我们需要插入到数据库中的属性上添加@EnumValue

//这是一种通用枚举使用的第一种方法：使用@EnumValue注解
@Getter
public enum GenderEnum {
    MALE(1,"男"),
    FEMALE(2,"女");

    //这儿我们在gender属性上方添加@EnumValue注解，代表插入数据库时是将该枚举类型的gender属性值插入到数据库中
    //如果我们要将genderName插入的话，就在genderName上方添加该注解
    @EnumValue
    private Integer gender;
    private String genderName;

    GenderEnum(Integer gender,String genderName){
        this.gender = gender;
        this.genderName = genderName;
    }
}
//第二种方法：将自定义枚举实现IEnun接口
@Getter
public enum GenderEnum implements IEnum<Integer> {//IEnum接口的泛型填写该枚举中我们需要存入数据库中的属性的类型，然后实现getValue方法，在getValue方法中返回我们需要存入数据库中的属性值
    MALE(1,"男"),
    FEMALE(2,"女");

    private Integer gender;
    private String genderName;

    GenderEnum(Integer gender,String genderName){
        this.gender = gender;
        this.genderName = genderName;
    }
    
    @Override
    public Integer getValue() {
        return this.gender;
    }
}

然后，在application.yaml配置文件中配置扫描通用枚举（ 注意：从Mybatis-plus3.5.2开始，无需进行配置）

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath:mapper/*.xml
  # 配置扫描通用枚举的包
  type-enums-package: com.xk.mybatisplus.entity

测试：

@Test
void testEnum(){
    User user = new User();
    user.setName("Enum");
    user.setAge(20);
    user.setGender(GenderEnum.MALE);
    //INSERT INTO t_user ( uid, name, age, gender ) VALUES ( ?, ?, ?, ? )
    //Parameters: 1543959249498730498(Long), Enum(String), 20(Integer), 1(Integer)
    userMapper.insert(user);//1
}

七、代码生成器

7.1 引入依赖

<!--代码生成器依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.2</version>
</dependency>
<!--模板引擎依赖，这个需要看自己使用什么模板，再决定导入什么依赖，默认 Velocity 可选模板引擎 Beetl 或 Freemarker-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.31</version>
</dependency>

7.2 复制代码

新建一个类，去到官网的代码生成器部分将代码复制粘贴到类中

public class CodeGenerator {
    public static void main(String[] args) {
        //将自己的数据库url、用户名、密码填写到这儿
        FastAutoGenerator.create("jdbc:mysql://localhost:3306/mybatisplus?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC", "root", "root")
                .globalConfig(builder -> {
                    builder.author("rainvex") // 设置作者
                            //.enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 是否覆盖已生成文件
                            .outputDir("E:\\JavaProject\\Study\\MybatisPlus\\src\\main\\java"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("com.xk.mybatisplus") // 设置父包名
                            .moduleName("generators") // 设置父包模块名，即我们要将生成的代码放到com.xk.mybatisplus下的哪个包下，这儿就说明我的是生成到com.xk.mybatisplus.generators包下
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "E:\\JavaProject\\Study\\MybatisPlus\\src\\main\\resources\\mapper")); // 设置mapper.xml文件生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("t_user","t_product") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();

    }
}

从代码生成器的配置可以看出，我们将数据表t_user、t_product对应的controller、service、mapper、实体类都生成到了E:\JavaProject\Study\MybatisPlus\src\main\java\com.xk.mybatisplus\generators包下，如果不想将生成的代码放到新的一个包下，而是直接覆盖之前的代码，那么则不设置moduleName即可，而对应的mapper.xml文件生成到了E:\JavaProject\Study\MybatisPlus\src\main\resources\mapper下

生成后的结果如图：

image-20220705114655460

八、多数据源

适用于多种场景：纯粹多库、 读写分离、 一主多从、 混合模式等

场景说明：创建两个库，分别为：mybatis_plus（以前的库不动）与mybatis_plus_1（新建），将mybatis_plus库的product表移动到mybatis_plus_1库，这样每个库一张表，通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功

8.1 新建数据库和表

新建一个数据库mybatisplus1，并新建一个表t_product，和之前的mybatisplus数据库中的一样

# 创建数据库
CREATE DATABASE `mybatisplus1`
use `mybatisplus1`;
# 创建数据表
CREATE TABLE t_product
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
    price INT(11) DEFAULT 0 COMMENT '价格',
    version INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
    PRIMARY KEY (id)
);
# 插入数据
INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

8.2 删除原有表

删除数据库mybatisplus中原有的t_product表

use mybatisplus;
DROP TABLE IF EXISTS t_product;

新建和删除表后，确保实体类的对应的表名和属性名正确

8.3 导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>

8.4 配置数据源

将之前的数据源配置删除，添加多数据源配置

spring:
  datasource:
    dynamic:
      # 设置默认的数据源或者数据源组,默认值即为master
      primary: master
      # 严格匹配数据源,默认false.当设置为true时若未匹配到指定数据源则抛异常,而false则会使用默认数据源
      strict: false
      datasource:
        master:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/mybatisplus?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
          username: root
          password: root
        slave1:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/mybatisplus1?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
          username: root
          password: root

8.5 添加@DS注解

在UserServiceImpl和ProductServiceImpl类上方添加@DS注解，指明该service要使用的数据源

@DS("master")
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

@DS("slave1")
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}

8.6 测试

@Autowired
private UserService userService;
@Autowired
private ProductService productService;

@Test
void testDatasource(){
    System.out.println(userService.getById(1L));
    //User(id=1, name=Jone, age=18, email=test1@baomidou.com, gender=null, isDelete=0)
    System.out.println(productService.getById(1L));
    //Product(id=1, name=外星人笔记本, price=100, version=0)
}
//当能分别查询出数据，说明多数据源配置成功

如果我们实现读写分离，将写操作方法加上主库数据源，读操作方法加上从库数据源，自动切换，就能实现读写分离