MyBatisPlus学习笔记

学习来源：尚硅谷

学习时间：2022年6月6日

1 MyBatisPlus简介

1.1 简介

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

我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

1.2 特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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.3 支持数据库

任何能使用MyBatis进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下：

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

1.4 框架结构

1.5 代码和文档地址

官方地址: http://mp.baomidou.com
代码发布地址:
- Github: https://github.com/baomidou/mybatis-plus
- Gitee: https://gitee.com/baomidou/mybatis-plus
文档发布地址: https://baomidou.com/pages/24112f

2 入门案例

2.1 创建数据库和表

创建表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */; 
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;

添加数据

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工程

使用 Spring Initializr 快速初始化一个 Spring Boot 工程。

引入依赖

<dependencies>
    <dependency> 
        <groupId>org.springframework.boot</groupId> 
        <artifactId>spring-boot-starter</artifactId> 
    </dependency>
    <dependency> 
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope> 
    </dependency> 
    <dependency> 
        <groupId>com.baomidou</groupId> 
        <artifactId>mybatis-plus-boot-starter</artifactId> 
        <version>3.5.1</version> 
    </dependency> 
    <dependency>
        <groupId>org.projectlombok</groupId> 
        <artifactId>lombok</artifactId> 
        <optional>true</optional>
    </dependency> 
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId> 
        <scope>runtime</scope>
    </dependency> 
</dependencies>

2.3 编写代码

2.3.1 配置文件

编写配置文件application.yml

spring: 
    # 配置数据源信息 
    datasource: 
        # 配置数据源类型 
        type: com.zaxxer.hikari.HikariDataSource 
        # 配置连接数据库信息 
        driver-class-name: com.mysql.cj.jdbc.Driver 
        url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false 
        username: root 
        password: 12345678

2.3.2 实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private Long id;

    private String name;

    private Integer age;

    private String email;

}

2.3.3 mapper类

BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的实体类型。

@Repository
public interface UserMapper extends BaseMapper<User> { 
    
}

BaseMapper接口的结构

2.3.4 启动类

在Spring Boot启动类中添加@MapperScan注解，扫描mapper包。

@SpringBootApplication
// 扫描mapper接口的包
@MapperScan("com.hongyi.mybatisplusdemo.mapper")
public class MybatisplusdemoApplication {

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

}

2.3.5 测试

@SpringBootTest
public class MyBatisPlusTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void test0() {
        // 通过条件构造器查询一个list集合
        // 如果没有条件则设置为null
        List<User> users = userMapper.selectList(null);
        users.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)

注意：IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确的执行。为了避免报错，可以在mapper接口上添加 @Repository 注解

2.3.6 日志功能

1
2
3

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

打印结果：

==>  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

3 基本CRUD

3.1 BaseMapper

MyBatis-Plus中的基本CRUD在内置的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 条件，查询一条记录 
    * <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常 </p> 
    * @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"); 
            }
            return ts.get(0); 
        }
        return null; 
    }
    
    /**
    * 根据 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 条件，查询全部记录 
    * <p>注意： 只返回第一个字段的值</p> 
    * @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);
}

3.2 增

@Test
public void test1() {
    // INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    User user = new User(null, "Mark", 24, "123@123.com");
    int result = userMapper.insert(user);
    System.out.println("result: " + result);
    // 获取自增的主键
    System.out.println("id: " + user.getId());
}

执行结果：

==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
==> Parameters: 1534785750812393473(Long), Mark(String), 24(Integer), 123@123.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@611e5819]
result: 1
id: 1534785750812393473

注意：最终执行的结果，所获取的id为1534785750812393473

这是因为MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id

3.3 删

3.3.1 通过id删除

@Test
public void test2() {
    // DELETE FROM user WHERE id=?
    int result = userMapper.deleteById(1534785750812393473L);
    System.out.println("result: " + result);
}

3.3.2 通过Map删除

@Test
public void test3() {
    // DELETE FROM user WHERE name = ? AND age = ?
    Map<String ,Object>  map = new HashMap<>();
    // map里放的就是删除的条件
    map.put("name", "Jone");
    map.put("age", 18);
    int result = userMapper.deleteByMap(map);
    System.out.println("result: " + result);
}

3.3.3 通过id批量删除

@Test
public void test4() {
    // DELETE FROM user WHERE id IN ( ? , ? , ? )
    List<Long> idList = Arrays.asList(1L, 2L, 3L);
    // 需要传入Collection集合
    int result = userMapper.deleteBatchIds(idList);
    System.out.println("result: " + result);
}

3.4 改

通过id修改数据。

@Test
public void test5() {
    // UPDATE user SET name=?, email=? WHERE id=?
    User user = new User();
    user.setId(4L);
    user.setName("Mark");
    user.setEmail("123456789@qq.com");
    int result = userMapper.updateById(user);
    System.out.println("result: " + result);
}

3.5 查

3.5.1 根据id查询

@Test
public void test6() {
    // SELECT id,name,age,email FROM user WHERE id=?
    User user = userMapper.selectById(4L);
    System.out.println(user);
}

3.5.2 根据多个id查询多个用户信息

@Test
public void test7() {
    // SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
    List<Long> idList = Arrays.asList(4L, 5L);
    List<User> users = userMapper.selectBatchIds(idList);
    users.forEach(System.out::println);
}

3.5.3 通过map条件查询用户信息

@Test
public void test8() {
    // SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
    Map<String ,Object>  map = new HashMap<>();
    map.put("name", "Mark");
    map.put("age", 21);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

3.5.4 查询所有数据

略。

通过观察BaseMapper中的方法，大多方法中都有Wrapper类型的形参，此为条件构造器，可针对于SQL语句设置不同的条件，若没有条件，则可以为该形参赋值null，即查询（删除/修改）所有数据。

3.6 通用Service

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

3.6.1 IService

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑。

3.6.2 创建Service接口和实现类

UserService继承IService模板提供的基础功能，同时还可以自定义需要实现的功能

1
2
3

public interface UserService extends IService<User> {

}

ServiceImpl实现了IService，提供了IService中基础功能的实现。若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现。注意ServiceImpl的泛型。

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

3.6.3 测试

① 测试查询记录数

@SpringBootTest
public class MyBatisPlusServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void test0() {
        // SELECT COUNT( * ) FROM user
        long count = userService.count();
        System.out.println("总记录数: " + count);
    }
}

② 测试批量插入

SQL长度有限制，海量数据插入单条SQL无法实行，因此MP将批量插入放在了通用Service中实现，而不是通用Mapper。

@Test
public void test1() {
    // INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    List<User> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        User user = new User();
        user.setName("ybc" + i);
        user.setAge(20 + i);
        user.setEmail("123@111.com");
        list.add(user);
    }
    boolean b = userService.saveBatch(list);
    System.out.println(b);
}

4 常用注解

4.1 @TableName

4.1.1 出现的问题

经过以上的测试，在使用MyBatis-Plus实现基本的CRUD时，我们并没有指定要操作的表，只是在Mapper接口继承BaseMapper时，设置了泛型User，而操作的表为user表。

由此得出结论，MyBatis-Plus在确定操作的表时，由BaseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致。

若实体类类型的类名和要操作的表的表名不一致，会出现什么问题？我们将表user更名为t_user，测试查询功能。

程序抛出异常，Table ‘mybatis_plus.user’ doesn’t exist，因为现在的表名为t_user，而默认操作的表名和实体类型的类名一致，即user表。

4.1.2 解决

① 单个配置

在实体类类型上添加@TableName("t_user")，标识实体类对应的表，即可成功执行SQL语句

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("t_user")
public class User {

    private Long id;

    private String name;

    private Integer age;

    private String email;

}

② 全局配置

在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_，此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就不需要在每个实体类上通过@TableName标识实体类对应的表。

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 设置全局设置
  global-config:
    db-config:
      # 配置MyBatis-Plus操作表的默认前缀
      table-prefix: t_

4.2 @TableId

经过以上的测试，MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。

4.2.1 出现的问题

若实体类和表中表示主键的不是id，而是其他字段，例如uid，MyBatis-Plus会自动识别uid为主键列吗？

我们实体类中的属性id改为uid，将表中的字段id也改为uid，测试添加功能。

程序抛出异常，Field 'uid' doesn't have a default value，说明MyBatis-Plus没有将uid作为主键赋值。

4.2.2 解决

在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句

public class User {
    @TableId
    private Long uid;
    
    private String name;
    private Integer age;
    private String email;
}

① value属性

若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解@TableId，则抛出异常Unknown column 'id' in 'field list'，即MyBatis-Plus仍然会将id作为表的主键操作，而表中表示主键的是字段uid。

此时需要通过@TableId注解的value属性，指定表中的主键字段，@TableId("uid")或者@TableId(value="uid")

② type属性

type属性用来定义主键策略。

常用的主键策略
- IdType.ASSIGN_ID（默认）：基于雪花算法的策略生成数据id，与数据库id是否设置自增无关
- IdType.AUTO：使用数据库的自增策略，注意，该类型请确保数据库设置了id自增，否则无效

全局主键策略的配置

mybatis-plus: 
	configuration: 
        # 配置MyBatis日志 
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl 
    global-config: 
        db-config: 
            # 配置MyBatis-Plus操作表的默认前缀 
            table-prefix: t_ 
            # 配置MyBatis-Plus的主键策略 
            id-type: auto

4.2.3 雪花算法

① 背景

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

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

② 主键自增

以最常见的用户 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）。

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

4.3 @TableField

经过以上的测试，我们可以发现，MyBatis-Plus在执行SQL语句时，要保证实体类中的属性名和表中的字段名一致。

如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？

4.3.1 情况1

若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格。

例如实体类属性userName，表中字段user_name

此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格

4.3.2 情况2

若实体类中的属性和表中的字段不满足情况1

例如实体类属性name，表中字段username

此时需要在实体类属性上使用@TableField("username")设置属性所对应的字段名

public class User {
    @TableId
    private Long uid;
    // 指定属性所对应的数据库字段
    @TableField("user_name")
    private String name;
    private Integer age;
    private String email;
}

@Test
public void test1() {
    // INSERT INTO user ( id, user_name, age, email ) VALUES ( ?, ?, ?, ? )
    User user = new User(null, "Mark", 24, "123@123.com");
    int result = userMapper.insert(user);
    System.out.println("result: " + result);
    // 获取自增的主键
    System.out.println("id: " + user.getUid());
}

4.4 @TableLogic

4.4.1 逻辑删除

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

4.4.2 实现

数据库中创建逻辑删除状态列，设置默认值为0

在实体类中添加逻辑删除属性

public class User {
    @TableId
    private Long uid;

    @TableField("user_name")
    private String name;

    private Integer age;

    private String email;
    
    // 逻辑删除
    @TableLogic
    private Integer isDeleted;

}

测试

@Test
public void test2() {
    // 实际执行的sql
    // UPDATE t_user SET is_deleted=1 WHERE uid=? AND is_deleted=0
    int result = userMapper.deleteById(4L);
    System.out.println("result: " + result);
}

再测试查询功能，发现被逻辑删除的数据默认不会被查询。

@Test
public void test0() {
    // 实际执行的sql
    // SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}

5 条件构造器和常用接口

5.1 Wrapper类继承关系

Wrapper ：条件构造抽象类，最顶端父类
- AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
  - QueryWrapper ：查询条件封装
  - UpdateWrapper ： Update 条件封装
  - AbstractLambdaWrapper ：使用Lambda 语法
    - LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
    - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

5.2 QueryWrapper类

5.2.1 组装查询条件

需求：查询用户名包含a，年龄在20到30之间，且邮箱信息不为null的用户信息
selectList：接收条件构造器，返回符合条件的查询集合List

@Test
public void test0() {
    // 实际执行的sql：SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
    
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    // 支持链式调用
    // 注意第一个参数column表示数据库中表的字段名，不是类属性名
    queryWrapper.like("user_name", "a")
            .between("age", 20, 30)
            .isNotNull("email");
    // 使用条件构造器，返回一个集合
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.2.2 组装排序条件

需求：查询所有用户信息，按照年龄的降序排序，如果年龄相同，则按照id升序排序。

@Test
public void test1() {
    // SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 ORDER BY age DESC,uid ASC
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("age")
            .orderByAsc("uid");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

执行结果：

<==        Row: 1534800170259173377, ybc9, 29, 123@111.com, 0
<==        Row: 1534800170250784771, ybc8, 28, 123@111.com, 0
<==        Row: 1534800170250784770, ybc7, 27, 123@111.com, 0
<==        Row: 1534800170250784769, ybc6, 26, 123@111.com, 0
<==        Row: 1534800170242396161, ybc5, 25, 123@111.com, 0
<==        Row: 5, Billie, 24, test5@baomidou.com, 0
<==        Row: 1534800170234007555, ybc4, 24, 123@111.com, 0
<==        Row: 1535119542404096001, Mark, 24, 123@123.com, 0
<==        Row: 1535120090851221505, Mark, 24, 123@123.com, 0
<==        Row: 1535125160917594113, Mark, 24, 123@123.com, 0
<==        Row: 1534800170234007554, ybc3, 23, 123@111.com, 0
<==        Row: 1534800170234007553, ybc2, 22, 123@111.com, 0
<==        Row: 1534800170225618945, ybc1, 21, 123@111.com, 0
<==        Row: 1534800170015903745, ybc0, 20, 123@111.com, 0

5.2.3 组装删除条件

需求：（逻辑）删除邮箱地址为null的用户
delete：接收条件构造器，删除符合条件的数据

@Test
public void test2() {
    // UPDATE t_user SET is_deleted=1 WHERE is_deleted=0 AND (email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.isNull("email");
    int delete = userMapper.delete(queryWrapper);
    System.out.println("受影响的行数: " + delete);
}

5.2.4 组装修改条件

需求：将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
update：接收实体类对象和条件构造器

@Test
public void test3() {
    // UPDATE t_user SET user_name=?, email=? WHERE is_deleted=0 AND (age > ? AND user_name LIKE ? OR email IS NULL)
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.gt("age", 20)
            .like("user_name", "a")
            .or() // 用于连接两个条件（或关系），默认连接用与关系
            .isNull("email");
    User user = new User();
    // 修改姓名和邮箱
    user.setName("小鸣");
    user.setEmail("123@google.com");
    int update = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数: " + update);
}

5.2.5 条件的优先级

需求：将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改

// UPDATE t_user SET user_name=?, email=? WHERE is_deleted=0 AND (user_name LIKE ? AND (age > ? OR email IS NULL))
// lambda表达式内的逻辑优先运算
@Test
public void test4() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like("user_name", "a")
        .and(i -> i.gt("age", 20).or().isNull("email"));
    User user = new User();
    user.setName("小刚");
    user.setEmail("123456@google.com");
    int update = userMapper.update(user, queryWrapper);
    System.out.println("受影响的行数: " + update);
}

and方法声明为：
- Nested public QueryWrapper<Param> and(Consumer<QueryWrapper<Param>> consumer)
- Param为泛型。支持链式调用
- and方法接收一个消费者（消费者泛型为QueryWrapper<Param>），可以使用lambda表达式

5.2.6 组装select子句

需求：查询用户信息的username和age字段
selectMaps：返回一个以map为元素的list集合

@Test
public void test5() {
    // SELECT user_name,age FROM t_user WHERE is_deleted=0
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("user_name", "age");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    maps.forEach(System.out::println);
}

5.2.7 子查询

需求：查询id小于等于100的用户信息

@Test
public void test6() {
    // SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (uid IN (select uid from t_user where uid <= 100))
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.inSql("uid", "select uid from t_user where uid <= 100");
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.3 UpdateWrapper类

UpdateWrapper可以直接设置要修改的字段

代码示例

需求：将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改

@Test
public void test7() {
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.like("user_name", "a")
            .and(i -> i.gt("age", 20).or().isNull("email"));
    // 可以直接在updateWrapper中设置要修改的字段
    updateWrapper.set("user_name", "小红").set("email", "123@163.com");
    // 由于没有创建实体类对象，因此第一个参数传入null即可
    int update = userMapper.update(null, updateWrapper);
    System.out.println("受影响的行数: " + update);
}

5.4 condition

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。

5.4.1 思路1

@Test
public void test8() {
    // 定义查询条件，有可能为null（用户未输入或未选择）
    String username = "a";
    Integer ageBegin = null;
    Integer ageEnd = 30;
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotBlank(username)) {
        // isNotBlank判断某个字符串是否不为空字符串,null和空白符
        queryWrapper.like("user_name", username);
    }
    if (ageBegin != null) {
        queryWrapper.ge("age", ageBegin);
    }
    if (ageEnd != null) {
        queryWrapper.le("age", ageEnd);
    }
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

实际执行的sql：

1	SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 AND (user_name LIKE ? AND age <= ?)

发现当ageBegin不符合条件时，并未出现在sql语句的条件中。

5.4.2 思路2

思路1的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数（一个布尔表达式）的重载方法构建查询条件，简化代码的编写.

@Test
public void test9() {
    String username = "a";
    Integer ageBegin = null;
    Integer ageEnd = 30;
    // 带condition的重载方法
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.like(StringUtils.isNotBlank(username), "user_name", username)
            .ge(ageBegin != null, "age", ageBegin)
            .le(ageEnd != null, "age", ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.5 LambdaQueryWrapper类

为防止第二个参数的数据库字段写出，可以使用LambdaQueryWrapper，第二个参数使用lambda表达式。

@Test
public void test10() {
    String username = "a";
    Integer ageBegin = null;
    Integer ageEnd = 30;
    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.like(StringUtils.isNotBlank(username), User::getName, username)
            .ge(ageBegin != null, User::getAge, ageBegin)
            .le(ageEnd != null, User::getAge, ageEnd);
    List<User> users = userMapper.selectList(queryWrapper);
    users.forEach(System.out::println);
}

5.6 LambdaUpdateWrapper类

@Test 
public void test10() { 
    //组装set子句 
    LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>(); 
    updateWrapper .set(User::getAge, 18) .set(User::getEmail, "user@atguigu.com") 
        .like(User::getName, "a") 
        .and(i -> i.lt(User::getAge, 24)
        .or()
        .isNull(User::getEmail)); 
    //lambda 表达式内的逻辑优先运算 
    User user = new User(); 
    int result = userMapper.update(user, updateWrapper);
    System.out.println("受影响的行数：" + result); 
}

6 插件

6.1 分页插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能。

6.1.1 添加配置类

新增配置类config.MyBatisPlusConfig

@Configuration
public class MyBatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 选择数据库类型
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

6.1.2 测试

基本使用

@Test
public void test0() {
    // 第几页
    // 每页数据的数量
    Page<User> page = new Page<>(2, 3);
    userMapper.selectPage(page, null);
    System.out.println(page);
}

执行的sql和查询的数据为：

==>  Preparing: SELECT uid,user_name AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0 LIMIT ?,?
==> Parameters: 3(Long), 3(Long)
<==    Columns: uid, name, age, email, is_deleted
<==        Row: 1534800170225618945, ybc1, 21, 123@111.com, 0
<==        Row: 1534800170234007553, ybc2, 22, 123@111.com, 0
<==        Row: 1534800170234007554, ybc3, 23, 123@111.com, 0
<==      Total: 3

表中数据，可见查询的是第二个红框内（第二页）的数据：

分页数据的获取

@Test 
public void testPage(){ 
    //设置分页参数 
    Page<User> page = new Page<>(2, 3); 
    userMapper.selectPage(page, null); 
    //获取分页数据 
    List<User> list = page.getRecords(); 
    list.forEach(System.out::println); 
    System.out.println("当前页："+page.getCurrent()); 
    System.out.println("每页显示的条数："+page.getSize()); 
    System.out.println("总记录数："+page.getTotal()); 
    System.out.println("总页数："+page.getPages()); 
    System.out.println("是否有上一页："+page.hasPrevious()); 
    System.out.println("是否有下一页："+page.hasNext()); 
}

User(uid=1534800170225618945, name=ybc1, age=21, email=123@111.com, isDeleted=0)
User(uid=1534800170234007553, name=ybc2, age=22, email=123@111.com, isDeleted=0)
User(uid=1534800170234007554, name=ybc3, age=23, email=123@111.com, isDeleted=0)
当前页：2
每页显示的条数：3
总记录数：15
总页数：5
是否有上一页：true
是否有下一页：true

6.2 自定义xml分页

需求：根据年龄查询用户列表，分页显示

6.2.1 定义接口方法

@Repository
public interface UserMapper extends BaseMapper<User> {

    /**
     * 通过年龄查询用户信息并分页
     * @param page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位
     * @param age 年龄
     * @return 分页数据
     */
    Page<User> selectPageVo(@Param("page") Page<User> page, @Param("age") Integer age);

}

6.2.2 UserMapper.xml中编写SQL

<?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.hongyi.mybatisplusdemo.mapper.UserMapper">
    <select id="selectPageVo" resultType="User">
        select uid, user_name, age, email from t_user where age > #{age}
    </select>
</mapper>

注意：resultType使用了默认的类型别名，需要在配置文件中设置：

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      table-prefix: t_
  # 设置类型别名
  type-aliases-package: com.hongyi.mybatisplusdemo.pojo

6.2.3 测试

@Test
public void test0() {
    //设置分页参数
    Page<User> page = new Page<>(3, 3);
    // 对年龄大于20的用户进行分类
    userMapper.selectPageVo(page, 24);
    //获取分页数据
    List<User> list = page.getRecords();
    list.forEach(System.out::println);
    System.out.println("当前页："+page.getCurrent());
    System.out.println("每页显示的条数："+page.getSize());
    System.out.println("总记录数："+page.getTotal());
    System.out.println("总页数："+page.getPages());
    System.out.println("是否有上一页："+page.hasPrevious());
    System.out.println("是否有下一页："+page.hasNext());
}

执行结果：

==>  Preparing: SELECT COUNT(*) AS total FROM t_user WHERE age > ?
==> Parameters: 24(Integer)
<==    Columns: total
<==        Row: 5
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@4aebee4b]
当前页：3
每页显示的条数：3
总记录数：5
总页数：2
是否有上一页：true
是否有下一页：false

6.3 乐观锁和悲观锁

6.3.1 场景

一件商品，成本价是80元，售价是100元。老板先是通知小李，说你去把商品价格增加50元。小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王，你把商品价格降低30元。

此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。是的，如果没有锁，小李的操作就完全被小王的覆盖了。

现在商品价格是70元，比成本价低10元。几分钟后，这个商品很快出售了1千多件商品，老板亏1万多。

上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出的被修改后的价格，150元，这样他会将120元存入数据库。
如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元。

6.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) 
);

1	INSERT INTO t_product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

② 实体类和mapper

@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;
}

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

③ 测试

@Test 
public void testConcurrentUpdate() { 
    //1、小李 
    Product p1 = productMapper.selectById(1L); 
    System.out.println("小李取出的价格：" + p1.getPrice()); 
    
    //2、小王 
    Product p2 = productMapper.selectById(1L); 
    System.out.println("小王取出的价格：" + p2.getPrice());
    
    //3、小李将价格加了50元，存入了数据库 
    p1.setPrice(p1.getPrice() + 50); 
    int result1 = productMapper.updateById(p1); 
    System.out.println("小李修改结果：" + result1); 
    
    //4、小王将商品减了30元，存入了数据库 
    p2.setPrice(p2.getPrice() - 30); 
    int result2 = productMapper.updateById(p2); 
    System.out.println("小王修改结果：" + result2); 
    
    //最后的结果 
    Product p3 = productMapper.selectById(1L); 
    //价格覆盖，最后的结果：70 
    System.out.println("最后的结果：" + p3.getPrice()); 
}

6.3.3 乐观锁

① 乐观锁实现流程

数据库中添加version字段。
取出记录时，获取当前version。

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

更新时，version + 1，如果where语句中的version版本不对，则更新失败。

1	UPDATE product SET price=price+50, `version`=`version` + 1 WHERE id=1 AND `version`=1

② Mybatis-Plus实现乐观锁

修改实体类

@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    @Version // 标识乐观锁版本号字段
    private Integer version;
}

配置乐观锁插件

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

测试修改冲突

小李查询商品信息：

SELECT id,name,price,version FROM t_product WHERE id=?

小王查询商品信息：

SELECT id,name,price,version FROM t_product WHERE id=?

小李修改商品价格，自动将version+1

UPDATE t_product SET name=?, price=?, version=? WHERE id=? AND version=?

Parameters: 外星人笔记本(String), 150(Integer), 1(Integer), 1(Long), 0(Integer)

小王修改商品价格，此时version已更新，条件不成立，修改失败

UPDATE t_product SET name=?, price=?, version=? WHERE id=? AND version=?（未执行）

Parameters: 外星人笔记本(String), 70(Integer), 1(Integer), 1(Long), 0(Integer)

最终，小王修改失败，查询价格：150

SELECT id,name,price,version FROM t_product WHERE id=?

优化修改流程

@Test
public void testConcurrentUpdate() {
    //1、小李
    Product p1 = productMapper.selectById(1L);
    System.out.println("小李取出的价格：" + p1.getPrice());

    //2、小王
    Product p2 = productMapper.selectById(1L);
    System.out.println("小王取出的价格：" + p2.getPrice());

    //3、小李将价格加了50元，存入了数据库
    p1.setPrice(p1.getPrice() + 50);
    int result1 = productMapper.updateById(p1);
    System.out.println("小李修改结果：" + result1);

    //4、小王将商品减了30元，存入了数据库
    p2.setPrice(p2.getPrice() - 30);
    int result2 = productMapper.updateById(p2);
    
    
    // -------------------优化------------------------
    if (result2 == 0) {
        // 操作失败，则重试
        Product p_new = productMapper.selectById(1L);
        p_new.setPrice(p_new.getPrice() - 30);
        int result3 = productMapper.updateById(p_new);
        System.out.println("小李修改结果：" + result3);
    }
    // -------------------优化------------------------

    //最后的结果
    Product p3 = productMapper.selectById(1L);
    //价格覆盖，最后的结果：70
    System.out.println("最后的结果：" + p3.getPrice());
}

7 通用枚举

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

在数据库表添加字段sex：

创建通用枚举类型

@AllArgsConstructor
@Getter
public enum SexEnum {
    MALE(1, "男"),
    FEMALE(2, "女");

    @EnumValue // 将注解所标识的属性的值存储到数据库中
    private Integer sex;
    
    private String sexName;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    // other codes...

    private SexEnum sex;

}

配置扫描通用枚举类的包

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      table-prefix: t_
  # 设置类型别名
  type-aliases-package: com.hongyi.mybatisplusdemo.pojo
  # 扫描通用枚举的包
  type-enums-package: com.hongyi.mybatisplusdemo.enums

测试

@Test
public void test0() {
    User user = new User();
    user.setName("zs");
    user.setAge(33);
    // 设置性别信息为枚举项，会将@EnumValue注解所标识的属性值存储到数据库
    user.setSex(SexEnum.MALE);
    int insert = userMapper.insert(user);
    System.out.println(insert);
}

执行结果

8 代码生成器

8.1 依赖

<dependency> 
    <groupId>com.baomidou</groupId> 
    <artifactId>mybatis-plus-generator</artifactId> 
    <version>3.5.1</version> 
</dependency> 
<dependency> 
    <groupId>org.freemarker</groupId> 
    <artifactId>freemarker</artifactId> 
    <version>2.3.31</version> 
</dependency>

8.2 快速生成

public class FastAutoGeneratorTest {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus? characterEncoding=utf-8&userSSL=false", "root", "123456") 	.globalConfig(builder -> { 
            builder.author("atguigu") // 设置作者 
                //.enableSwagger() // 开启 swagger 模式 
                .fileOverride() // 覆盖已生成文件 
                .outputDir("D://mybatis_plus"); // 指定输出目录
        })
            .packageConfig(builder -> { 
                builder.parent("com.atguigu") // 设置父包名 
                    .moduleName("mybatisplus") // 设置父包模块名 
               .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D://mybatis_plus")); // 设置mapperXml生成路径 
            }).strategyConfig(builder -> { 
            builder.addInclude("t_user") // 设置需要生成的表名 
                .addTablePrefix("t_", "c_"); // 设置过滤表前缀 
        })
            .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker 引擎模板，默认的是Velocity引擎模板 
            .execute(); 
    } 
}

9 多数据源

9.1 场景准备

适用于多种场景：纯粹多库、读写分离、一主多从、混合模式等。目前我们就来模拟一个纯粹多库的一个场景，其他场景类似。

场景说明：

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

创建数据库和表

CREATE DATABASE `mybatis_plus_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 */; 
use `mybatis_plus_1`; 
CREATE TABLE 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) 
);

1	INSERT INTO product (id, NAME, price) VALUES (1, '外星人笔记本', 100);

删除原库的表

1 2	use mybatis_plus; DROP TABLE IF EXISTS product;

9.2 依赖

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

9.3 配置多数据源

spring:
  # 配置数据源信息
  datasource:
    dynamic:
      # 设置默认的数据源或者数据源组,默认值即为master
      primary: master
      # 严格匹配数据源,默认false.true未匹配到指定数据源时抛异常,false使用默认数据源
      strict: false
      datasource:
        # 主数据源
        master:
          url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 12345678
        # 从数据源
        slave_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 12345678

9.4 指定数据源

在service的实现类上使用注解@DS

//指定所操作的数据源
@DS("master")
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

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

9.5 测试

@SpringBootTest
public class MyBatisPlusDataSourceTest {

    @Autowired
    private UserService userService;

    @Autowired
    private ProductService productService;

    @Test
    public void test0() {
        System.out.println(userService.getById(4L));
        System.out.println(productService.getById(1L));
    }
}

打印信息：都能顺利获取对象，则测试成功。

1 2	User(uid=4, name=小鸣, age=21, email=123@google.com, isDeleted=0, sex=null) Product(id=1, name=外星人笔记本, price=100, version=0)

10 MyBatisX插件

MyBatisX是idea的一个插件。

10.1 代码快速生成

使用idea自带的功能连接数据库：

选择要操作的表：

填写信息：

生成的代码示例

@TableName(value ="t_user")
@Data
public class User implements Serializable {
    /**
     * 主键ID
     */
    @TableId(type = IdType.AUTO)
    private Long uid;

    /**
     * 姓名
     */
    private String userName;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 逻辑删除
     */
    private Integer isDeleted;

    /**
     * 性别
     */
    private Integer sex;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
    implements UserService{

}

10.2 CRUD快速生成

快捷键：alt enter

生成的代码示例

public interface UserMapper extends BaseMapper<User> {
    int insertSelective(User user);

    int deleteByUidAndUserName(@Param("uid") Long uid, @Param("userName") String userName);

    int updateAgeAndSexByUid(@Param("age") Integer age, @Param("sex") Integer sex, @Param("uid") Long uid);

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

    List<User> selectAllOrderByAgeDesc();

}

对应的mapper文件：

<insert id="insertSelective">
    insert into t_user
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="uid != null">uid,</if>
        <if test="userName != null">user_name,</if>
        <if test="age != null">age,</if>
        <if test="email != null">email,</if>
        <if test="isDeleted != null">is_deleted,</if>
        <if test="sex != null">sex,</if>
    </trim>
    values
    <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="uid != null">#{uid,jdbcType=BIGINT},</if>
        <if test="userName != null">#{userName,jdbcType=VARCHAR},</if>
        <if test="age != null">#{age,jdbcType=INTEGER},</if>
        <if test="email != null">#{email,jdbcType=VARCHAR},</if>
        <if test="isDeleted != null">#{isDeleted,jdbcType=INTEGER},</if>
        <if test="sex != null">#{sex,jdbcType=INTEGER},</if>
    </trim>
</insert>

<delete id="deleteByUidAndUserName">
    delete
    from t_user
    where uid = #{uid,jdbcType=NUMERIC}
    AND user_name = #{userName,jdbcType=VARCHAR}
</delete>

<update id="updateAgeAndSexByUid">
    update t_user
    set age = #{age,jdbcType=NUMERIC},
    sex = #{sex,jdbcType=NUMERIC}
    where uid = #{uid,jdbcType=NUMERIC}
</update>

<select id="selectAgeAndSexByAgeBetween" resultMap="BaseResultMap">
    select age, sex
    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>

MybatisPlus学习笔记

MyBatisPlus学习笔记

1 MyBatisPlus简介

1.1 简介

1.2 特性

1.3 支持数据库

1.4 框架结构

1.5 代码和文档地址

2 入门案例

2.1 创建数据库和表

2.2创建SpringBoot工程

2.3 编写代码

2.3.1 配置文件

2.3.2 实体类

2.3.3 mapper类

2.3.4 启动类

2.3.5 测试

2.3.6 日志功能

3 基本CRUD

3.1 BaseMapper

3.2 增

3.3 删

3.3.1 通过id删除

3.3.2 通过Map删除

3.3.3 通过id批量删除

3.4 改

3.5 查

3.5.1 根据id查询

3.5.2 根据多个id查询多个用户信息

3.5.3 通过map条件查询用户信息

3.5.4 查询所有数据

3.6 通用Service

3.6.1 IService

3.6.2 创建Service接口和实现类

3.6.3 测试

① 测试查询记录数

② 测试批量插入

4 常用注解

4.1 @TableName

4.1.1 出现的问题

4.1.2 解决

① 单个配置

② 全局配置

4.2 @TableId

4.2.1 出现的问题

4.2.2 解决

① value属性

② type属性

4.2.3 雪花算法

① 背景

② 主键自增

③ 取模

④ 雪花算法

4.3 @TableField

4.3.1 情况1

4.3.2 情况2

4.4 @TableLogic

4.4.1 逻辑删除

4.4.2 实现

5 条件构造器和常用接口

5.1 Wrapper类继承关系

5.2 QueryWrapper类

5.2.1 组装查询条件

5.2.2 组装排序条件

5.2.3 组装删除条件

5.2.4 组装修改条件

5.2.5 条件的优先级

5.2.6 组装select子句

5.2.7 子查询

5.3 UpdateWrapper类

5.4 condition

5.4.1 思路1

5.4.2 思路2

5.5 LambdaQueryWrapper类

5.6 LambdaUpdateWrapper类

6 插件

6.1 分页插件

6.1.1 添加配置类

6.1.2 测试

6.2 自定义xml分页