* MyBatis-plus（mp）

目标
一、MyBatisPlus简介
- 1. 入门案例
- 2. MyBatisPlus概述
二、标准数据层开发
- 1. MyBatisPlus的CRUD操作
- 2. MyBatisPlus分页功能
三、DQL编程控制
四、DML编程控制
五、代码生成器

目标

能够基于MyBatisPlus完成标准Dao开发
能够掌握MyBatisPlus的条件查询
能够掌握MyBatisPlus的字段映射与表名映射
能够掌握id生成策略控制
能够理解代码生成器的相关配置
一、MyBatisPlus简介
1. 入门案例

推荐：wrapper每次使用都不同推荐使用mp，如果wrapper存在重复使用推荐原生mybatis开发代码冗余的使用原生Mybatis，代码不冗余使用mp Wrapper：条件构造抽象类，是最顶级的父类；**

问题导入

MyBatisPlus环境搭建的步骤？

SpringBoot整合MyBatisPlus入门程序

①：创建新模块mybatis-plus-01

* MyBatis-plus（mp） - 图1

③：添加相关的起步依赖

多余的文件和依赖配置都可以删除了
* MyBatis-plus（mp） - 图2
pom.xml文件如下：

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.5.6</version>
    </parent>
    <dependencies>
        <!--springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- spring整合test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!-- mybatis-plus的驱动包 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
        <!-- mysql要选择正确版本的驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

注意事项：如果使用Druid数据源，需要导入对应坐标

④：制作实体类与表结构

（类名与表名对应，属性名与字段名对应）
SQL脚本

CREATE DATABASE IF NOT EXISTS mybatisplus_db CHARACTER SET utf8;
USE mybatisplus_db;
CREATE TABLE `user` (
            id BIGINT(20) PRIMARY KEY AUTO_INCREMENT,
            `name` VARCHAR(32) NOT NULL,
            gender CHAR(1),
            `password`  VARCHAR(32) NOT NULL,  
            age INT(3) NOT NULL ,
            tel VARCHAR(32) NOT NULL
);
INSERT INTO `user` VALUES(NULL,'Rose','女','123456',12,'12345678910');
INSERT INTO `user` VALUES(NULL,'Jack','男','123456',8,'12345678910');
INSERT INTO `user` VALUES(NULL,'Jerry','男','123456',15,'12345678910');
INSERT INTO `user` VALUES(NULL,'NewBoy','男','123456',19,'12345678910');
INSERT INTO `user` VALUES(NULL,'Kate','女','123456',28,'12345678910');
INSERT INTO `user` VALUES(NULL,'张晓','女','123456',22,'12345678910');
INSERT INTO `user` VALUES(NULL,'张大炮','男','123456',16,'12345678910');
SELECT * FROM `user`;

* MyBatis-plus（mp） - 图3
在domain目录下创建实体类
* MyBatis-plus（mp） - 图4

package com.itheima.domain;
import lombok.Data;
@Data
public class User {
    private Long id;
    private String name;
    private String gender;
    private String password;
    private Integer age;
    private String tel;
}

⑤：设置Jdbc参数（application.yml）

# 数据源的配置
spring:
  datasource:
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql:///mybatisplus_db
# 显示SQL语句
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

⑥：定义数据接口，继承BaseMapper

接口上要添加@Mapper注解

package com.itheima.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.domain.User;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

⑦：测试类中注入dao接口，测试功能

建议把测试类的包移入com.itheima.test包中，修改类名Demo1MybatisPlusTest
测试类上添加@SpringBootTest注解
注入UserMapper

selectList查询所有用户，参数为null

package com.itheima.test;
import com.itheima.dao.UserMapper;
import com.itheima.domain.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
class Demo1MybatisPlusTest {
 @Autowired
 private UserMapper userMapper;
 @Test
 void testGetAll() {
     List<User> userList = userMapper.selectList(null);
     System.out.println(userList);
 }
}

小结

使用mybatisplus的步骤 ```

导入mp的启动器
编写application.yml文件，配置数据源，打印日志
编写mapper接口，Mapper接口需要基础BaseMapper接口，BaseMapper接口需要指定操作的是哪个实体类。
在启动类中扫描的Mapper包
测试使用 ```
2. MyBatisPlus概述
问题导入
通过入门案例制作，MyBatisPlus的优点有哪些？
1. MyBatis介绍

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

2. MyBatisPlus特性
无侵入：只做增强不做改变，不会对现有工程产生影响
强大的 CRUD 操作：内置通用 Mapper，少量配置即可实现单表CRUD 操作(如果只做单表增删查改不需要你写任何的sql)
支持 Lambda：编写查询条件无需担心字段写错
支持主键自动生成
内置分页插件

……

二、标准数据层开发

1. MyBatisPlus的CRUD操作

package com.itheima.test;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class MyBatisTest01 {
  @Autowired(required = false)
  private UserMapper userMapper;
  @Test
  public void testFindById(){
      List<User> userList = userMapper.selectList(null);
      System.out.println("用户对象："+ userList);
  }
  /**
   * 增加
   */
  @Test
  public void testInsert(){
      User user = new User();
      user.setName("itheima");
      user.setGender("男");
      user.setPassword("root");
      user.setAge(19);
      user.setTel("18000110011");
      userMapper.insert(user);
  }
  /**
   * 删除
   */
  @Test
  public void testRemove(){
      userMapper.deleteById(1480751909521403906L);
  }
  /**
   * 更新
   */
  @Test
  public void testUpdate(){
      User user =new User();
      user.setId(7L);
      user.setName("张小炮");  //注意： 生成update语句设置的字段为非空字段。
      userMapper.updateById(user); //update user set xx=xx ,xxx=xx ,xx=xx where id =xx
  }
  /**
   * 条件查询
   */
  @Test
  public void testFindByCondition(){
      //QueryWrapper代表就是条件
      QueryWrapper<User> queryWrapper  = new QueryWrapper<>();
      //添加条件
      queryWrapper.gt("age",18);
      List<User> userList = userMapper.selectList(queryWrapper);
      System.out.println("用户列表："+ userList);
  }
}

2. MyBatisPlus分页功能

问题导入

思考一下Mybatis分页插件是如何用的？

1 分页功能接口

2 MyBatisPlus分页使用

①：设置分页拦截器作为Spring管理的bean

在config包下创建一个配置类：MybatisPlusConfig
在类上添加_@_Configuration
编写方法
1. 方法上使用@Bean注解：添加MybatisPlusInterceptor对象到容器中
2. 创建MybatisPlusInterceptor拦截器对象
3. 添加内部分页拦截器：创建PaginationInnerInterceptor ```java package com.itheima.config; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /**
- 如果需要使用到mybatis-plus的分页功能，必须存在一个配置类
- 该配置类创建Mybatis的拦截器，这个拦截器的作用就是在你执行selectPage的方法的时候
- 对sql进行拦截，然后拼接limit语句实现分页。 / @Configuration public class MybatisPlusConfig { @Bean public MybatisPlusInterceptor createMybatisPlusInterceptor(){ //1. 创建Mybatisplus拦截器 MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor(); //2. 往拦截器中添加分页拦截器 mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor()); //3 .返回 return mybatisPlusInterceptor; } } ``` *②：在测试类中执行分页查询
创建分页对象，前面是接口IPage，后面是实现类Page(第几页，每页大小)
调用selectPage方法，传入page对象，无需接收返回值

获取分页结果

/**
  * 分页查询
  */
 @Test
 public void testPage(){
     //1. 设置当前页与页面大小
     Page<User> page =new Page<>(1,2); //当前页1  页面大小是2
     //2. 创建分页需要条件
     QueryWrapper queryWrapper = new QueryWrapper();
     //3. 调用selectPage方法实现分页，分页的结果会被封装到Page对象中
     userMapper.selectPage(page,queryWrapper);
     System.out.println("页面大小："+page.getSize());
     System.out.println("页面数据："+page.getRecords());
     System.out.println("当前页："+page.getCurrent());
     System.out.println("总记录数："+page.getTotal());
     System.out.println("总页数："+page.getPages());
 }

疑问：我们使用selectPage的方法的时候可以使用mp的分页功能，如果我们是自定义方法，自己去编写sql语句能否也用上mp的分页功能？答案：可以
要求如下： ```

如果自己实现的sql语句需要使用分页功能，那么该方法必须接收一个Page对象。

方法的返回值必须也是一个Page对象

```java
package com.itheima.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.domain.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface UserMapper extends BaseMapper<User> {
 @Select("select * from user where age>#{age}")
 public Page<User> selectByAge(Page<User> page, @Param("age") Integer age);
}

测试方法

/**
  * 分页查询
  */
 @Test
 public void testPage2(){
     //1. 设置当前页与页面大小
     Page<User> page =new Page<>(1,2); //当前页1  页面大小是2
     userMapper.selectByAge(page,10);
     System.out.println("页面大小："+page.getSize());
     System.out.println("页面数据："+page.getRecords());
     System.out.println("当前页："+page.getCurrent());
     System.out.println("总记录数："+page.getTotal());
     System.out.println("总页数："+page.getPages());
 }

小结

mp要实现分页功能的步骤：
- 编写配置类，配置类中创建拦截器
- 创建Page对象设置当前页与页面大小
- 创建条件对象 queryWrap
- 调用selectPage方法或者是自己定义分页方法。
  三、DQL编程控制
  1. 条件查询方式
MyBatisPlus将书写复杂的SQL查询条件进行了封装，使用编程的形式完成查询条件的组合

* MyBatis-plus（mp） - 图7

1.1 条件查询

两者的区别：（有两种条件查询的方式） QueryWrapper 与 LambdaQueryWrapper

创建新的测试类：Demo2ConditionTest

package com.itheima.test;
import com.itheima.dao.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class Demo2ConditionTest {
    @Autowired
    private UserMapper userMapper;
}

1.1.1 方式一：按条件查询

查询年龄大于18岁的用户 wrapper.gt(“age”, 18);

@Test
void testQueryWrapper() {
    //1. 创建查询条件封装对象，可以指定泛型
    QueryWrapper<User> wrapper = new QueryWrapper();
    //2.字段age大于18
    wrapper.gt("age", 18);
    //3.执行查询
    List<User> users = userMapper.selectList(wrapper);
    //4.输出结果
    users.forEach(System.out::println);
}

1.1.2 方式二：lambda格式按条件查询（推荐）

查询年龄小于10的用户 wrapper.le(User::getAge, 10);

@Test
void testLambdaQueryWrapper() {
    //1.创建lambda查询包装器，支持泛型
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper();
    //2. 使用lambda参数，相当于调用 user -> user.getAge()方法，获取列名
    wrapper.le(User::getAge, 10);
    //3.查询
    List<User> users = userMapper.selectList(wrapper);
    //4.输出结果
    users.forEach(System.out::println);
}

1.2 组合条件

1.2.1 并且关系（and）

查询年龄小于30岁，而且大于10岁的用户 wrapper.lt(User::getAge, 30).gt(User::getAge, 10);

@Test
void testAnd() {
    //并且关系
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    //支持链式写法
    wrapper.lt(User::getAge, 30).gt(User::getAge, 10);
    List<User> userList = userMapper.selectList(wrapper);
    System.out.println(userList);
}

生成的SQL语句

SELECT id,name,gender,password,age,tel FROM user WHERE (age < ? AND age > ?)

1.2.2 或者关系（or）

查询年龄小于10岁或者大于30岁的用户 wrapper.lt(User::getAge, 10).or().gt(User::getAge, 30);

@Test
void testOr() {
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    //或者关系：小于10岁或者大于30岁
    wrapper.lt(User::getAge, 10).or().gt(User::getAge, 30);
    List<User> userList = userMapper.selectList(wrapper);
    System.out.println(userList);
}

生成的SQL语句

SELECT id,name,gender,password,age,tel FROM user WHERE (age < ? OR age > ?)

1.3 NULL值处理

问题导入

如下搜索场景，在多条件查询中，有条件的值为空应该怎么解决？
* MyBatis-plus（mp） - 图9

1.3.1，if语句控制条件追加

如果最小年龄不为空，则查询大于这个年龄的用户

如果最大年龄不为空，则查询小于这个年龄的用户

@Test
void testNullValue() {
  Integer minAge = 10;  //将来有用户传递进来,此处简化成直接定义变量了
  Integer maxAge = null;  //将来有用户传递进来,此处简化成直接定义变量了
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  if (minAge != null) {
      wrapper.gt(User::getAge, minAge);  //大于
  }
  if (maxAge != null) {
      wrapper.lt(User::getAge, maxAge);  //小于
  }
  List<User> userList = userMapper.selectList(wrapper);
  userList.forEach(System.out::println);
}

1.3.2 条件参数控制

@Test
void testCondition() {
  Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
  Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  //参数1：如果表达式为true，那么查询才使用该条件，也支持链式编程
  wrapper.gt(minAge != null, User::getAge, minAge);
  wrapper.lt(maxAge != null, User::getAge, maxAge);
  //查询
  List<User> userList = userMapper.selectList(wrapper);
  //输出
  userList.forEach(System.out::println);
}

2. 查询投影-设置【查询字段、分组、分页】

创建新的测试类：

/**
* 查询投影
*/
@SpringBootTest
public class Demo3ProjectionTest {
  @Autowired
  private UserMapper userMapper;
}

1 查询结果包含模型类中部分属性

查询所有用户，只显示id, name, age三个属性，不是全部列。
使用select(列名...)方法，查询的结果如果封装成实体类，则只有这三个属性有值，其它属性为NULL

@Test
void testSameColumn() {
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  //查询所有用户，只显示id, name, age三个属性，不是全部列
  wrapper.select(User::getId, User::getName, User::getAge);
  List<User> userList = userMapper.selectList(wrapper);
  System.out.println(userList);
}

SQL语句

SELECT id,name,age FROM user

2 查询结果包含模型类中未定义的属性

如果查询结果包含模型类中未定义的属性，则将每个元素封装成Map对象。
需求：按性别进行分组，统计每组的人数。只显示统计的人数和性别这两个字段
使用QueryWrapper包装对象的select方法 wrapper.select(“count(*) as count, gender”);

@Test
void testCountGender() {
  //使用QueryWrapper包装对象
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  //查询2列：人数, 性别。 将聚合函数定义别名做为Map中的键
  wrapper.select("count(*) as count, gender");
  //按sex分组
  wrapper.groupBy("gender");
  //这里的查询方法使用selectMaps
  List<Map<String, Object>> list = userMapper.selectMaps(wrapper);
  list.forEach(System.out::println);
}

3. 查询条件

问题导入

多条件查询有哪些组合？

范围匹配（> 、 = 、between）
模糊匹配（like）
空判定（null）
包含性匹配（in）
分组（group）
排序（order）
……

3.1 查询条件

购物设定价格区间、户籍设定年龄区间（le ge匹配或 between匹配）

LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<User>();
//范围查询 lt le gt ge eq between
wrapper.between(User::getAge, 10, 30);
List<User> userList = userMapper.selectList(wrapper);
System.out.println(userList);

查信息，搜索新闻（非全文检索版：like匹配）

   /**
   * 需求: 查询姓张的用户
   *    select * from user where name like '张%'
   */
  @Test
  public void testFindByLike(){
      LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
      lambdaQueryWrapper.likeRight(User::getName,"张");
      List<User> userList = userMapper.selectList(lambdaQueryWrapper);
      userList.forEach(System.out::println);
  }

统计报表（分组查询聚合函数）

QueryWrapper<User> qw = new QueryWrapper<User>();
qw.select("gender", "count(*) as nums");
qw.groupBy("gender");
List<Map<String, Object>> maps = userMapper.selectMaps(qw);
System.out.println(maps);

3.2 排序和limit

题目：显示年龄最大的5个用户

说明：
①：提示：对年龄进行降序排序
②：仅获取前5条数据（提示：使用分页功能控制数据显示数量）

last()方法的说明：
无视优化规则直接拼接到 sql 的最后(有sql注入的风险,请谨慎使用)，注意只能调用一次,多次调用以最后一次为准

/**
   * 需求: 查询年龄大于18岁的前三位
   *      select * from user where age>18 order by age desc limit 3;
   *
   */
  @Test
  public void testFindByLimit(){
      LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
      lambdaQueryWrapper.gt(User::getAge,18).orderByDesc(User::getAge).last("limit 3");
      List<User> userList = userMapper.selectList(lambdaQueryWrapper);
      userList.forEach(System.out::println);
  }

生成的SQL

SELECT id,name,gender,password,age,tel FROM user WHERE (age > ?) ORDER BY age DESC limit 3

4. 字段映射与表名映射问题导入 _@_TableField *

思考表的字段和实体类的属性不对应，查询会怎么样？‘

报错：

4.1 问题一：表字段与编码属性设计不同步

在模型类属性上方，使用 _@_TableField 属性注解，通过==value==属性，设置当前属性对应的数据库表中的字段关系。
```
-- 修改表的列名
ALTER TABLE `user` CHANGE `password` `pwd` VARCHAR(20);
```
再次查询出现异常，报不知道的列password
```
com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown column 'password' in 'field list'
```
解决方法：

生成的SQL语句，自动给pwd这一列定义了别名为password, 从而给实体类属性password封装数据
```
SELECT id,name,gender,pwd AS password,age,tel FROM user
```
4.2 问题二：编码中添加了数据库中未定义的属性
在User实体类中添加新的属性Integer online
查询报错：
```
Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Unknown column 'online' in 'field list'
```
解决方法：
在模型类属性上方，使用_@_TableField 注解，通过exist属性，设置属性在数据库表字段中是否存在，默认为true。此属性无法与value同时使用。

* MyBatis-plus（mp） - 图12
再次查询结果，没有报错，但online的属性值为空

User(id=4, name=NewBoy, gender=男, password=123456, age=19, tel=12345678910, online=null)

4.3 问题三：某些字段和属性不参与查询

需求：password这个字段不查询

在模型类属性上方，使用_@_TableField 注解，通过select属性：设置该属性是否参与查询。此属性与select()映射配置不冲突。

* MyBatis-plus（mp） - 图13
查询的SQL语句中不包含pwd字段

SELECT id,name,gender,age,tel FROM user WHERE id=?

实体类的password属性中没有值

User(id=4, name=NewBoy, gender=男, password=null, age=19, tel=12345678910, online=null)

4.4 问题四：表名与实体类名不同

修改表名：

-- 修改表的名字
ALTER TABLE `user` RENAME TO tbl_user;

运行出现异常：

Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'mybatisplus_db.user' doesn't exist

解决方法：

在模型类上方，使用_@_TableName 注解，通过value属性，设置当前类对应的数据库表名称。

* MyBatis-plus（mp） - 图14

@Data
@TableName("tbl_user")
public class User {
}

查询生成的SQL语句

SELECT id,name,gender,age,tel FROM tbl_user WHERE id=?

四、DML编程控制

1. id生成策略控制（Insert）

默认使用雪花算法进行id生成策略；

问题导入

主键生成的策略有哪几种方式？
不同的表应用不同的id生成策略

日志：自增（1,2,3,4，……）
购物订单：特殊规则（FQ23948AK3843）
外卖单：关联地区日期等信息（10 04 20200314 34 91）
关系表：可省略id
……

1.1 id生成策略控制（@TableId注解）
名称：_@_TableId
类型：属性注解
位置：模型类中用于表示主键的属性定义上方
作用：设置当前类中主键属性的生成策略
相关属性
type：设置主键属性的生成策略，值参照IdType枚举值

针对每个公司，随着服务化演进，单个服务越来越多，数据库分的越来越细，有的时候一个业务需要分成好几个库，这时候自增主键或者序列之类的主键id生成方式已经不再满足需求，分布式系统中需要的是一个全局唯一的id生成规则。具体的算法和代码，参见资料文件夹。

添加无参和有参的构造方法

@Data
@TableName("tbl_user")
public class User {
    public User() {
    }
    public User(Long id, String name, String gender, String password, Integer age, String tel) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.password = password;
        this.age = age;
        this.tel = tel;
    }
    //使用雪花算法
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    private String name;
    private String gender;
    @TableField("pwd")
    private String password;
    private Integer age;
    private String tel;
}

测试

@Test
void insertUser() {
    //创建用户
    User user = new User(null,"孙悟天","男","12345",8,"15022334455");
    UserMapper.insert(user);
}

执行的SQL语句
* MyBatis-plus（mp） - 图16

1.2 全局策略配置

也可以在application.yml中进行全局的配置

id-type 让所有表主键生成策略相同

table-prefix 在每个实体类的前面添加相同的前缀

mybatis-plus:
global-config:
 db-config:
   id-type: assign_id
   table-prefix: tbl_

id生成策略全局配置

表名前缀全局配置

实体类：去了@TableName注解和_@_TableId

@Data
public class User {
 public User() {
 }
 public User(Long id, String name, String gender, String password, Integer age, String tel) {
     this.id = id;
     this.name = name;
     this.gender = gender;
     this.password = password;
     this.age = age;
     this.tel = tel;
 }
 private Long id;
 private String name;
 private String gender;
 @TableField("pwd")
 private String password;
 private Integer age;
 private String tel;
}

再次测试结果

2. 多记录操作（批量Delete/Select）

问题导入

MyBatisPlus是否支持批量操作？
* MyBatis-plus（mp） - 图20

2.1 按照主键删除多条记录

使用方法：deleteBatchIds()

//删除指定多条数据
List<Long> list = new ArrayList<>();
list.add(1402551342481838081L);
list.add(1402553134049501186L);
list.add(1402553619611430913L);
userMapper.deleteBatchIds(list);

生成的SQL语句

DELETE FROM tbl_user WHERE id IN ( ? , ? , ? )

2.2 根据主键查询多条记录

使用方法：selectBatchIds()

//查询指定多条数据
List<Long> list = new ArrayList<>();
list.add(1L);
list.add(3L);
list.add(4L);
userMapper.selectBatchIds(list);

生成的SQL语句

SELECT id,name,gender,pwd AS password,age,tel FROM tbl_user WHERE id IN ( ? , ? , ? )

3. 逻辑删除（Delete/Update）

问题导入

在实际环境中，如果想删除一条数据，是否会真的从数据库中删除该条数据？

删除操作业务问题：业务数据从数据库中丢弃
逻辑删除：为数据设置是否可用状态字段，删除时设置状态字段为不可用状态，数据保留在数据库中

* MyBatis-plus（mp） - 图21

3.1 逻辑删除案例

修改表结构

-- 添加一列deleted，注意设置默认值为0
ALTER TABLE tbl_user ADD COLUMN deleted INT(1) DEFAULT 0;
-- 查看结构
DESC tbl_user;

①：数据库表中添加逻辑删除标记字段

* MyBatis-plus（mp） - 图22

②：实体类中添加对应字段，并设定当前字段为逻辑删除标记字段

@TableLogic包含以下属性

value：未删除时的值
delval：删除了的值 ```java @Data public class User { private Long id;

//逻辑删除字段，标记当前记录是否被删除 @TableLogic private Integer deleted;

}

<a name="mwNre"></a>
##### ③：配置逻辑删除字面值
```yaml
mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除字面值：未删除为0
      logic-not-delete-value: 0
      # 逻辑删除字面值：删除为1
      logic-delete-value: 1

逻辑删除本质：逻辑删除的本质其实是修改操作。如果加了逻辑删除字段，查询数据时也会自动带上逻辑删除字段。

@Test
void testLogicDeleted() {
    int row = UserMapper.deleteById(5);
    System.out.println(row + "条记录被逻辑删除");
}

* MyBatis-plus（mp） - 图23

4. 乐观锁（Update）

4.1 问题导入

乐观锁主张的思想是什么？

业务并发现象带来的问题：秒杀

* MyBatis-plus（mp） - 图24

4.2 什么是悲观锁和乐观锁

悲观锁(Pessimistic Lock)

当要对数据库中的一条数据进行修改的时候，为了避免同时被其他人修改，最好的办法就是直接对该数据进行加锁以防止并发。这种借助数据库锁机制，在修改数据之前先锁定，再修改的方式被称之为悲观锁。
之所以叫做悲观锁，是因为这是一种对数据的修改持有悲观态度的并发控制方式。总是假设最坏的情况，每次读取数据的时候都默认其他线程会更改数据，因此需要进行加锁操作，当其他线程想要访问数据时，都需要阻塞挂起。

乐观锁(Optimistic Locking)

乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，乐观锁适用于读多写少的场景，这样可以提高程序的吞吐量。
乐观锁采取了更加宽松的加锁机制。也是为了避免数据库幻读、业务处理时间过长等原因引起数据处理错误的一种机制，但乐观锁不会刻意使用数据库本身的锁机制，而是依据数据本身来保证数据的正确性。

乐观锁的实现

CAS 实现：Java 中java.util.concurrent.atomic包下面的原子变量使用了乐观锁的一种 CAS 实现方式。

版本号控制：一般是在数据表中加上一个数据版本号 version 字段，表示数据被修改的次数。当数据被修改时，version 值会 +1。当线程 A 要更新数据时，在读取数据的同时也会读取 version 值，在提交更新时，若刚才读取到的 version 值与当前数据库中的 version 值相等时才更新，否则重试更新操作，直到更新成功。

乐观锁本质是利用多线程进行修改（一个线程修改失败就需要不断循环尝试修改，可能会导致饥饿线程），如果修改的操作多就会导致线程也多，更多的线程不断循环运行，这样会导致cpu负载过高和性别变慢，所以乐观锁适合读多写少的情况。

4.3 乐观锁案例

①：数据库表中添加锁标记字段

ALTER TABLE tbl_user ADD COLUMN `version` INT DEFAULT 0;

* MyBatis-plus（mp） - 图25

②：实体类中添加对应字段，并设定当前字段为版本控制字段

@Version注解

package com.itheima.domain;
@Data
public class User {
 private Long id;

 @Version
 private Integer version;
}

③：配置乐观锁拦截器实现锁机制对应的动态SQL语句拼装

package com.itheima.config;
@Configuration
public class MybatisPlusConfig {
 @Bean
 public MybatisPlusInterceptor mybatisPlusInterceptor() {
     //1.定义Mp拦截器
     MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
     //2.添加乐观锁拦截器
     mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

     return mpInterceptor;
 }
}

④：使用乐观锁机制在修改前必须先获取到对应数据的version方可正常进行

@Test
public void testUpdateOne() {
 //1.先通过要修改的数据id将当前数据查询出来
 User user = userMapper.selectById(2L);
 //2.将要修改的属性逐一设置进去
 user.setName("Jock888");
 userMapper.updateById(user);
}

* MyBatis-plus（mp） - 图26
模拟多条记录同时更新

@Test
public void testUpdateTwo() {
 //先通过要修改的数据id将当前数据查询出来
 User user1 = userMapper.selectById(2L);     //version=2
 User user2 = userMapper.selectById(2L);    //version=2
 user1.setName("Jack aaa");
 userMapper.updateById(user1);              //version=>3
 user2.setName("Jack bbb");
 userMapper.updateById(user2);               //verion=2 更新失败
}

第二条记录更新失败
* MyBatis-plus（mp） - 图27

小结

在mp里面如果需要使用乐观锁的步骤： ```

数据库的表必须添加version字段
```
    2.  添加乐观锁的拦截器
    3.  以后你执行update语句的时候记得实体类要设置当前version的值
```
```

乐观锁，仅适用于低并发的业务需求；实际运用会使用分布式锁；

五、代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
以后只需要创建好表，然后entti实体类，dao、service、controller都可以自动生成.

5.1创建maven工程

创建maven工程：mybatisplus_code
* MyBatis-plus（mp） - 图28

5.2 导入依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>javaee164</groupId>
    <artifactId>mybatis_plus_02_code_autogenerator</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.6.2</version>
    </parent>
    <dependencies>
    <!--代码生成器-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-generator</artifactId>
        <version>3.4.0</version>
    </dependency>
    <!--模块引擎-->
    <dependency>
        <groupId>org.freemarker</groupId>
        <artifactId>freemarker</artifactId>
        <version>2.3.30</version>
    </dependency>
    <!--下面是生成后的代码需要用到的依赖-->
    <!--web启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--mybatis启动器-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <!--druid的启动器-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
        <!--JUNIT单元测试启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

5.3 代码生成类

创建test包，复制此类到包下

package cn.itcast.test;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }
    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        //设置模块名
        String moduleName = scanner("请代码存储的模块名");
        gc.setOutputDir(projectPath + "/"+moduleName+"/src/main/java");
        //代码的作者
        gc.setAuthor("itheima");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);
        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/springdb?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        mpg.setDataSource(dsc);
        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("功能模块名"));
        //设置父级包名   com.itheima.user  com.itheima.teacher
        pc.setParent("com.itheima");
        mpg.setPackageInfo(pc);
        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };
        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/"+moduleName+"/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);
        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();
        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);
        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        strategy.setEntityLombokModel(true);
        strategy.setRestControllerStyle(true);
        // 公共父类
        // strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 写于父类中的公共字段
        // strategy.setSuperEntityColumns("id");
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        strategy.setControllerMappingHyphenStyle(true);
        String preName = scanner("请输入表前缀名");
        strategy.setTablePrefix(preName); // 设置表前缀
        mpg.setStrategy(strategy);
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        // 执行
        mpg.execute();
    }
}

5.4 执行

右键运行main函数，在控制台输入功能模块名，表名，再按回车即可
* MyBatis-plus（mp） - 图29
执行完成后刷新项目，发现代码已经生成完毕，每个表都生成对应每一层的代码：
* MyBatis-plus（mp） - 图30

目标

一、MyBatisPlus简介

1. 入门案例

问题导入

SpringBoot整合MyBatisPlus入门程序

①：创建新模块mybatis-plus-01

③：添加相关的起步依赖

④：制作实体类与表结构

⑤：设置Jdbc参数（application.yml）

⑥：定义数据接口，继承BaseMapper

⑦：测试类中注入dao接口，测试功能

小结

2. MyBatisPlus概述

问题导入

1. MyBatis介绍

2. MyBatisPlus特性

二、标准数据层开发

1. MyBatisPlus的CRUD操作

2. MyBatisPlus分页功能

问题导入

1 分页功能接口

2 MyBatisPlus分页使用

小结

三、DQL编程控制

1. 条件查询方式

1.1 条件查询

1.1.1 方式一：按条件查询

1.1.2 方式二：lambda格式按条件查询（推荐）

1.2 组合条件

1.2.1 并且关系（and）

1.2.2 或者关系（or）

1.3 NULL值处理

问题导入

1.3.1，if语句控制条件追加

1.3.2 条件参数控制

2. 查询投影-设置【查询字段、分组、分页】

1 查询结果包含模型类中部分属性

2 查询结果包含模型类中未定义的属性

3. 查询条件

问题导入

3.1 查询条件

3.2 排序和limit

4. 字段映射与表名映射问题导入 _@_TableField *

4.1 问题一：表字段与编码属性设计不同步

4.2 问题二：编码中添加了数据库中未定义的属性

4.3 问题三：某些字段和属性不参与查询

4.4 问题四：表名与实体类名不同

四、DML编程控制

1. id生成策略控制（Insert）

问题导入

1.1 id生成策略控制（@TableId注解）

1.2 全局策略配置

id生成策略全局配置

表名前缀全局配置

2. 多记录操作（批量Delete/Select）

问题导入

2.1 按照主键删除多条记录

2.2 根据主键查询多条记录

3. 逻辑删除（Delete/Update）

问题导入

3.1 逻辑删除案例

①：数据库表中添加逻辑删除标记字段

②：实体类中添加对应字段，并设定当前字段为逻辑删除标记字段

4. 乐观锁（Update）

4.1 问题导入

4.2 什么是悲观锁和乐观锁

悲观锁(Pessimistic Lock)

乐观锁(Optimistic Locking)

乐观锁的实现

4.3 乐观锁案例

①：数据库表中添加锁标记字段

②：实体类中添加对应字段，并设定当前字段为版本控制字段

③：配置乐观锁拦截器实现锁机制对应的动态SQL语句拼装

④：使用乐观锁机制在修改前必须先获取到对应数据的version方可正常进行

小结

五、代码生成器

5.1创建maven工程

5.2 导入依赖

5.3 代码生成类