导入

mybatis 缺点：

• 在小的sql也需要人去手写
• 动态sql写起来很僵硬
• 代码量大，不简洁

mybatisPlus的出现，全部一键集成，实现基友搭配，效率翻倍！！！

学习目标

• 能够基于MyBatisPlus完成标准Dao开发
• 能够掌握MyBatisPlus的条件查询
• 能够掌握MyBatisPlus的字段映射与表名映射
• 能够掌握id生成策略控制
• 能够理解代码生成器的相关配置

一、MyBatisPlus简介

1. 入门案例

1.1 SpringBoot整合MyBatisPlus入门程序

①：创建新模块，选择Spring初始化，并配置模块相关基础信息

②：选择当前模块需要使用的技术集（仅保留JDBC)

③：手动添加MyBatisPlus起步依赖

<parent>
    <!--从父亲那里继承过来springboot启动信息-->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.0</version>
</parent>
<dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>
     	<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

注意事项1：由于mp并未被收录到idea的系统内置配置，无法直接选择加入

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

④：制作实体类与表结构

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

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,
            password  varchar(32) not null,
            age int(3) not null ,
            tel varchar(32) not null
);
insert into user values(null,'tom','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,'tom','123456',9,'12345678910');
insert into user values(null,'snake','123456',28,'12345678910');
insert into user values(null,'张益达','123456',22,'12345678910');
insert into user values(null,'张大炮','123456',16,'12345678910');

public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
    //自行添加getter、setter、toString()等方法
}

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

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource

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

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

@Mapper//mybatis框架定义 描述数据层接口的注解 用于告诉spring框架这个接口实现类由mybatis创建 将存储到spring容器中
public interface UserDao extends BaseMapper<User> {
}

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

package com.itgaohe;

import com.itgaohe.dao.UserDao;
import com.itgaohe.pojo.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
public class MpAppTests {
    @Autowired
    private UserDao userDao;
    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
}

2. MyBatisPlus概述

2.1 MyBatis介绍

• MyBatisPlus（简称MP）是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提高效率

• 官网：https://mybatis.plus https://mp.baomidou.com

2.2 MyBatisPlus特性

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

问题导入

有什么简单的办法可以自动生成实体类的GET、SET方法？

• Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发。

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>

• 常用注解：@Data，为当前实体类在编译期设置对应的get/set方法，无参/无参构造方法，toString方法，hashCode方法，equals方法等

package com.itgaohe.pojo;

import lombok.*;
/*
    1 生成getter和setter方法：@Getter、@Setter
      生成toString方法：@ToString
      生成equals和hashcode方法：@EqualsAndHashCode

    2 统一成以上所有：@Data

    3 生成空参构造： @NoArgsConstructor
      生成全参构造： @AllArgsConstructor

    4 lombok还给我们提供了builder的方式创建对象,好处就是可以链式编程。 @Builder【扩展】
 */
@Data
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}

2. MyBatisPlus的CRUD操作

package com.itgaohe;

import com.itgaohe.dao.UserDao;
import com.itgaohe.pojo.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 MpAppTests {

    @Autowired
    private UserDao userDao;
//增加数据
    @Test
    void testSave() {
        User user = new User();
        user.setName("高合科技");
        user.setPassword("itgaohe");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }
//删除
    @Test
    void testDelete() {
        userDao.deleteById(1401856123725713409L);
    }
//修改
    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Tom888");
        user.setPassword("tom888");
        userDao.updateById(user);
    }
//查询
    @Test
    void testGetById() {
        User user = userDao.selectById(2L);
        System.out.println(user);
    }
//查询所有
    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
//自定义方法
}

3. MyBatisPlus分页功能

问题导入

3.1 分页功能接口

3.2 MyBatisPlus分页使用

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

package com.itgaohe.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;

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //1 创建MybatisPlusInterceptor拦截器对象
        MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

②：执行分页查询

//分页查询
@Test
void testSelectPage(){
    //1 创建IPage分页对象,设置分页参数
    IPage<User> page=new Page<>(1,3);
    //2 执行分页查询
    userDao.selectPage(page,null);
    //3 获取分页结果
    System.out.println("当前页码值："+page.getCurrent());
    System.out.println("每页显示数："+page.getSize());
    System.out.println("总页数："+page.getPages());
    System.out.println("总条数："+page.getTotal());
    System.out.println("当前页数据："+page.getRecords());
}

3.3 开启MyBatisPlus日志

代替前面我们用的日志依赖。

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC
    username: root
    password: 123456
# 开启mp的日志（输出到控制台）
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3.4 解决日志打印过多问题

3.4.1 取消初始化spring日志打印

做法：在resources下新建一个logback.xml文件，名称固定，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

</configuration>

关于logback参考播客：https://www.jianshu.com/p/75f9d11ae011

3.4.2 取消SpringBoot启动banner图标

spring:
  main:
    banner-mode: off # 关闭SpringBoot启动图标(banner)

3.4.3 取消MybatisPlus启动banner图标

# mybatis-plus日志控制台输出
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    banner: off # 关闭mybatisplus启动图标

三、DQL编程控制

1. 条件查询方式

• MyBatisPlus将书写复杂的SQL查询条件进行了封装，使用编程的形式完成查询条件的组合。

1.1 条件查询

1.1.1 方式一：按条件查询

tips：这种方式是全能的

//方式一：按条件查询
QueryWrapper<User> qw=new QueryWrapper<>();
qw.lt("age", 18);
List<User> userList = userDao.selectList(qw);
System.out.println(userList);

类名::get属性

这是Java 8中的方法引用，它可以用来获取一个类的属性。

具体来说，Java 类名::get属性可以用来获取该类中指定属性的getter方法的引用。

例如，如果有一个User类，其中有一个name属性，那么User::getName就是获取name属性的getter方法的引用。

这个方法引用可以用来获取属性的名称、类型、拥有的注解等信息，从而可以进行各种操作。

1.1.2 方式二：lambda格式按条件查询

//方式二：lambda格式按条件查询
QueryWrapper<User> qw = new QueryWrapper<User>();
qw.lambda().lt(User::getAge, 10);
List<User> userList = userDao.selectList(qw);
System.out.println(userList);

1.1.3 方式三：lambda格式按条件查询（推荐）

tips:这种方式不是全能的，聚合查询无法使用

//方式三：lambda格式按条件查询
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.lt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

1.2 组合条件

小案例：
// 1.age between 12 and  18
// 2.查询年龄>18 或者 年龄<12
// age between 12 and  null 当用户年龄上限传递null值如何处理
//完成聚合查询count()  min  max  avg  sum

1.2.1 并且关系（and）

//并且关系
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//并且关系：10到30岁之间
lqw.lt(User::getAge, 30).gt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

1.2.2 或者关系（or）

//或者关系
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//或者关系：小于10岁或者大于30岁
lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

1.2.3 在…之间 （between）

@Test
public void testByCondition4(){
    LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<>();
    lqw.between(User::getAge,10,18);
    List<User> users = userDao.selectList(lqw);
    System.out.println(users);
}

1.3 NULL值处理

问题导入

如下搜索场景，在多条件查询中，有条件的值为空应该怎么解决？

1.3.1 if语句控制条件追加

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

1.3.2 条件参数控制

Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//参数1：如果表达式为true，那么查询才使用该条件
lqw.gt(minAge!=null,User::getAge, minAge);
lqw.lt(maxAge!=null,User::getAge, maxAge);
List<User> userList = userDao.selectList(lqw);
userList.forEach(System.out::println);

1.3.3 条件参数控制（链式编程）

Integer minAge=10;  //将来有用户传递进来,此处简化成直接定义变量了
Integer maxAge=null;  //将来有用户传递进来,此处简化成直接定义变量了
LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//参数1：如果表达式为true，那么查询才使用该条件
lqw.gt(minAge!=null,User::getAge, minAge)
   .lt(maxAge!=null,User::getAge, maxAge);
List<User> userList = userDao.selectList(lqw);
userList.forEach(System.out::println);

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

查询投影：只查询某些字段信息，其余字段为null/0

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

/*LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.select(User::getId, User::getName, User::getAge);*/
//或者
QueryWrapper<User> lqw = new QueryWrapper<User>();
lqw.select("id", "name", "age", "tel");
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

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

//聚合查询不能用 LambdaQueryWrapper

QueryWrapper<User> lqw = new QueryWrapper<User>();
lqw.select("count(*) as count, tel");
lqw.groupBy("tel");
List<Map<String, Object>> userList = userDao.selectMaps(lqw);
System.out.println(userList);

3. 查询条件设定

多条件查询有哪些组合？

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

3.1 查询条件

用户登录（eq匹配）
购物设定价格区间、户籍设定年龄区间（le ge匹配 或 between匹配）
查信息，搜索新闻（非全文检索版：like匹配）
统计报表（分组查询聚合函数）

• 用户登录（eq匹配）

LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//等同于=
lqw.eq(User::getName, "Jerry").eq(User::getPassword, "jerry");
User loginUser = userDao.selectOne(lqw);
System.out.println(loginUser);

• 购物设定价格区间、户籍设定年龄区间（le ge匹配 或 between匹配）
• lt < ,le <= , gt > ,ge >=,eq = ,between…

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

• 查信息，搜索新闻（非全文检索版：like匹配）
• likeLeft :LIKE ‘%值’
• likeRight LIKE ‘值%’
• like LIKE ‘%值%’

LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
//模糊匹配 like likeLeft  likeRight
lqw.likeLeft(User::getName, "J");
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

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

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

3.2 查询API

• 更多查询条件设置参看https://mp.baomidou.com/guide/wrapper.html

3.3 练习：MyBatisPlus练习

题目：基于MyBatisPlus_Ex1模块，完成Top5功能的开发。

• 说明：

  ①：Top5指根据销售量排序（提示：对销售量进行降序排序）

  ②：Top5是仅获取前5条数据（提示：使用分页功能控制数据显示数量）

select * from user order by age limit 0,5

 @Test
    public void testByCondition15() {
        //        QueryWrapper<User> qw = new QueryWrapper<>();
        //        qw.orderByDesc("age");
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<>();
        lqw.orderByDesc(User::getAge);
        IPage<User> page = new Page<>(1, 5);
        userDao.selectPage(page, lqw);
        List<User> records = page.getRecords();
        System.out.println(records);
    }

/*
    练习题
  1. 查询年龄的 top3
  2. 查询年龄10-20岁用户
  3. 模糊查询前 ‘张’姓用户
  4. 查询所有用户的平均年龄、最大年龄、最小年龄
  5. 对密码进行分组查询统计数量
 */
@Test
    public void show1(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper();
        lqw.orderByDesc(User::getAge);
        IPage<User> page = new Page<>(1,3);
        userDao.selectPage(page,lqw);
        System.out.println(page);
    }
    @Test
    public void show2(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper();
        lqw.ge(User::getAge,10).le(User::getAge,20);
        List<User> users = userDao.selectList(lqw);
        System.out.println(users);
    }
    @Test
    public void show3(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper();
        lqw.likeRight(User::getName,"张");
        List<User> users = userDao.selectList(lqw);
        System.out.println(users);
    }
    //4. 查询所有用户的平均年龄、最大年龄、最小年龄
    @Test
    public void show4(){
        QueryWrapper<User> lqw = new QueryWrapper();
        lqw.select("avg(age),max(age),min(age)");
        List<User> users = userDao.selectList(lqw);
        System.out.println(users);
    }
    @Test
    public void show5(){
        QueryWrapper<User> lqw = new QueryWrapper();
        lqw.select("password,count(*)");
        lqw.groupBy("password");
        List<Map<String, Object>> maps = userDao.selectMaps(lqw);
        System.out.println(maps);
    }

4. 字段映射与表名映射

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

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

• 在模型类属性上方，使用**@TableField**属性注解，通过==value==属性，设置当前属性对应的数据库表中的字段关系。

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

• 在模型类属性上方，使用**@TableField注解，通过exist**属性，设置属性在数据库表字段中是否存在，默认为true。此属性无法与value合并使用。
  

4.3 问题三：采用默认查询开放了更多的字段查看权限

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

4.4 问题四：表名与编码开发设计不同步

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

@Data
@TableName("tbl_user")
public class User {
    /*
        id为Long类型，因为数据库中id为bigint类型，
        并且mybatis有自己的一套id生成方案，生成出来的id必须是Long类型
     */
    private Long id;
    private String name;
    @TableField(value = "pwd",select = false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist = false) //表示online字段不参与CRUD操作
    private Boolean online;
}

or

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_

4.5 问题五：字段名驼峰命名

数据库中名字 user_name 实体类中 userName 匹配问题

• 默认自动匹配

• 也可以通过配置匹配

mybatis-plus:
	configuration:
	    #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射 address_book ---> AddressBook
	    map-underscore-to-camel-case: true

​

四、DML编程控制

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

问题导入

主键生成的策略有哪几种方式？

不同的表应用不同的id生成策略

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

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

• 名称：@TableId

• 类型：属性注解

• 位置：模型类中用于表示主键的属性定义上方

• 作用：设置当前类中主键属性的生成策略

• 相关属性

  ​ type：设置主键属性的生成策略，值参照IdType枚举值

  //默认是 雪花算法

  

雪花算法：分布式ID生成器
雪花算法是由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碰撞，并且效率较高。

1.2 全局策略配置

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

id生成策略全局配置

表名前缀全局配置

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

问题导入

MyBatisPlus是否支持批量操作？

2.1 按照主键删除多条记录

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

userDao.deleteBatchIds(list);

2.2 根据主键查询多条记录

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

3. 逻辑删除（Delete/Update）（很重要）

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

• 删除操作业务问题：业务数据从数据库中丢弃

• 逻辑删除：为数据设置是否可用状态字段，删除时设置状态字段为不可用状态，数据保留在数据库中

3.1 逻辑删除案例

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

填充字段的值为0

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

package com.itgaohe.domain;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;

@Data
public class User {
    private Long id;
    //逻辑删除字段，标记当前记录是否被删除 未删除是0 删除是1
    @TableLogic
    private Integer deleted;
    
}

③：配置逻辑删除字面值

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除字面值：未删除为0
      logic-not-delete-value: 0
      # 逻辑删除字面值：删除为1
      logic-delete-value: 1

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

4. 乐观锁（Update）

下面我们来说一下 修改操作中的一个问题，以及解决方案。

• 业务并发现象带来的问题：秒杀 查的多 并发多
• 我们接来下讲的在中小型企业可以用来解决 eg2000个请求以内

乐观锁是一种并发控制的策略，它假设多个线程在操作共享数据时，不会发生冲突，因此不需要加锁，而是在更新数据时，通过比较当前状态和上一次的状态，来判断是否有其他线程修改了数据。如果没有冲突，就执行更新操作，否则就重试或者放弃。乐观锁的优点是减少了锁的开销，提高了并发性能；缺点是可能会造成大量的重试开销，以及存在ABA问题。

4.1 乐观锁案例

乐观锁 最大目的是为了让每次进来的数据+1/-1 这里展示的+1操作。当有多个线程操作的时候 乐观锁会生效，保证一次进来的数据只有一个。

步骤：

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

②：实体类中添加对应字段，并设定当前字段为乐观锁标记字段

package com.itgaohe.domain;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.Version;
import lombok.Data;

@Data
public class User {

	private Long id;
	
    @Version
    private Integer version;
}

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

package com.itgaohe.config;

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

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mpInterceptor;
    }
}

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

@Test
    public void testUpdate(){
    //update set xx = xx,version=version+1 where version = 1;
    User user = new User();
    user.setId(8l);
    user.setName("aka666");
    user.setVersion(1);//如果一开始不添加 则数据修改 但是 version值没有添加 乐观锁没有生效
    userDao.updateById(user);
    }
    @Test
    public void testUpdate2(){
        //1.先通过要修改的数据id将当前数据查询出来
        User user = userDao.selectById(8l);
        //2.将要修改的属性逐一设置进去
        user.setName("aka888");
        userDao.updateById(user);
    }
    @Test
    public void testUpdate3(){
        //1.先通过要修改的数据id将当前数据查询出来
        User user = userDao.selectById(8l);     //version=3
        User user2 = userDao.selectById(8l);    //version=3
        user2.setName("Jock aaa");
        userDao.updateById(user2);              //version=>4
        user.setName("Jock bbb");
        userDao.updateById(user);               //verion=3?条件还成立吗？
        //通过这个可以看出在并发问题的时候 乐观锁可以良好的解决数据同步的问题。
    }

where 后面的值是你输入的。这个值要和数据库一致，不一致会查不到。

一致以后： 前面修改的版本 = version+1

五、快速开发-代码生成器

问题导入

如果只给一张表的字段信息，能够推演出Domain、Dao层的代码？

1. MyBatisPlus提供模板

• Mapper接口模板

• 实体对象类模板

2. 工程搭建和基本代码编写

• 第一步：创建SpringBoot工程，添加代码生成器相关依赖，其他依赖自行添加

<!--代码生成器-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>

<!--velocity模板引擎-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>

• 第二步：编写代码生成器类

package com.itgaohe;

import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;

public class Generator {
    public static void main(String[] args) {
        //1. 创建代码生成器对象，执行生成代码操作
        AutoGenerator autoGenerator = new AutoGenerator();

        //2. 数据源相关配置：读取数据库中的信息，根据数据库表结构生成代码
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        autoGenerator.setDataSource(dataSource);

         //3. 执行生成操作
        autoGenerator.execute();
    }
}

你会发现 会默认在d盘输出 com.baomidou

3. 开发者自定义配置

• 设置全局配置

//设置全局配置
GlobalConfig globalConfig = new GlobalConfig();
globalConfig.setOutputDir(System.getProperty("user.dir")+"/springboot_combine_mp2/src/main/java");    //设置代码生成位置
globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
globalConfig.setAuthor("高合信息科技");    //设置作者
globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
autoGenerator.setGlobalConfig(globalConfig);

• 设置包名相关配置

//设置包名相关配置
PackageConfig packageInfo = new PackageConfig();
packageInfo.setParent("com.itgaohe");   //设置生成的包名，与代码所在位置不冲突，二者叠加组成完整路径
packageInfo.setEntity("pojo");    //设置实体类包名
packageInfo.setMapper("dao");   //设置数据层包名
autoGenerator.setPackageInfo(packageInfo);

• 策略设置
• 先只保留 setTablePrefix 的代码执行。看效果

//策略设置
StrategyConfig strategyConfig = new StrategyConfig();
strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称，模块名 = 数据库表名 - 前缀名  例如： User = tbl_user - tbl_
strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
autoGenerator.setStrategy(strategyConfig);
 //3. 执行生成操作
autoGenerator.execute();

说明：在资料中也提供了CodeGenerator代码生成器类，根据实际情况修改后可以直接使用。

今日总结

• 能够基于MyBatisPlus完成标准Dao开发- crud
• 能够掌握MyBatisPlus的条件查询-
• 能够掌握MyBatisPlus的字段映射与表名映射
• 能够掌握id生成策略控制（了解）（面试）
• 了解删除策略(重点)、乐观锁（了解）（面试）
• 能够理解代码生成器的相关配置（了解）

Config);