MyBatis-Plus

MyBatis-Plus

1.入门

官方网址：https://mp.baomidou.com/

介绍： 为简化开发而生

1.1 简介

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

愿景

我们的愿景是成为 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 快速开始

我们将通过一个简单的 Demo 来阐述 MyBatis-Plus 的强大功能，在此之前，我们假设您已经：

• 拥有 Java 开发环境以及相应 IDE
• 熟悉 Spring Boot
• 熟悉 Maven

现有一张 User 表，其表结构如下：

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

1.3.1 创建数据库

CREATE DATABASE IF NOT EXISTS mp;

1.3.2 创建表

其对应的数据库 Schema 脚本如下：

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
	id BIGINT(20) NOT NULL COMMENT '主键ID',
	name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
	age INT(11) NULL DEFAULT NULL COMMENT '年龄',
	email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (id)
);

1.3.3 添加数据

其对应的数据库 Data 脚本如下：

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

1.3.4 创建项目

创建一个空的 Spring Boot 工程

1.添加依赖

3.3.x属于老版本，3.4.x属于新版，配置不一样

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>

2.添加配置

可以使用yml（推荐），也可以使用properties

注意：

1.格式化，按照缩进进行划分，默认是一个空格，在idea中tab也可以。：后面需要加上空格

# SpringBoot的版本 2.0之前，内置的JDBC的驱动 5.0 
# SpringBoot的版本 2.0之后，内置的JDBC的驱动 8.0 com.mysql.cj.jdbc.Driver
# 8.0 会有东八区的问题（时区）
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/mp?serverTimezone=GMT%2B8

3.在启动类上添加MapperScan

@MapperScan("cn.kgc.mp.mapper") // 这个地址要写完整
@SpringBootApplication
public class MpApplication {

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

}

4.新建实体类

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

5.新建Mapper

public interface UserMapper extends BaseMapper<User> {
}

6.初步测试

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

    // 1.查询所有的用户数据
    @Test
    public void testFindAll() {
        List<User> users = userMapper.selectList(null);
        System.out.println("------->> 执行selectList");
        users.forEach(System.out::println);
    }
}

2.基础的CRUD 重要

@Accessors(chain = true) // 链式操作，set之后的返回值由void变成一个User对象，注意在使用链式操作的时候，有一些帮助类无法使用

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 在控制台打印sql语句

2.1 Mapper

@SpringBootTest
public class MapperTest {

    @Autowired
    private UserMapper userMapper;

    // 1.根据id获取用户
    @Test
    public void testGetUserById() {
        User user = userMapper.selectById(1);
        System.out.println(user);
    }

    // 2.查询所有 - selectList 还可以使用selectMaps
    @Test
    public void testSelectMaps() {
        List<Map<String, Object>> list = userMapper.selectMaps(null);
        list.forEach(System.out::println);
    }

    // 3.根据id的集合查询对象
    @Test
    public void testSelectBatchIds() {
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

    // 4.根据map条件查询对象
    @Test
    public void testSelectByMap() {
        // 根据条件来进行添加的时候
        Map<String, Object> map = new HashMap<>();
        map.put("name", "Tom");
        map.put("age", 28);
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

    // ------------------------------查询结束------------------------------------

    // 5.新增
    @Test
    public void testInsert() {
        User user = new User();
        user.setName("王渊").setAge(18).setEmail("wangyuan@outlook.com");
        // 返回的是受影响的行数
        int number = userMapper.insert(user);
        System.out.println("受影响行数：" + number);
    }

    // 6.修改
    @Test
    public void testUpdateById() {
        User user = new User();
        user.setName("狄仁杰").setAge(1000).setEmail("drj@outlook.com").setId(1L);
        // 不需要我们额外的传入id，对象中有，mp会自己去找
        int number = userMapper.updateById(user);
        System.out.println("受影响行数：" + number);
    }

    // 7.删除
    @Test
    public void testDelById() {
        int number = userMapper.deleteById(2);
        System.out.println("受影响行数：" + number);
    }
}

2.2 Service

2.2.1 创建UserService

IService：基础的crud

public interface UserService extends IService<User> {
}

2.2.2 创建UserServiceImpl

ServiceImpl：是IService的实现，通过的UserMapper, User是实体类

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

2.2.3 测试service的crud

创建ServiceTest

@SpringBootTest
public class ServiceTest {
    @Autowired
    private UserService userService;

    // 1.新增
    @Test
    public void testSave() {
        User user = new User();
        user.setName("胡之欣").setAge(18).setEmail("hzx@outlook.com");
        boolean flag = userService.save(user);
        System.out.println("是否成功：" + flag);
    }

    // 2.修改
    @Test
    public void testUpdateById() {
        User user = new User();
        user.setName("孙凯敏").setAge(18).setEmail("Tom@outlook.com").setId(3L);
        boolean flag = userService.updateById(user);
        System.out.println("是否成功：" + flag);

    }

    // 3.新增或修改 - 如果对象中有id就是修改，没有就是新增
    @Test
    public void testSaveAndUpdate() {
        User user = new User();
        user.setName("石康").setAge(18).setEmail("Tom@outlook.com")/*.setId(4L)*/;
        boolean flag = userService.saveOrUpdate(user);
        System.out.println("是否成功：" + flag);
    }

    // 4.查询
    @Test
    public void testList() {
        List<User> list = userService.list();
        list.forEach(System.out::println);
    }
}

3.MP组件

3.1 分布式ID

MP默认给我们使用的就是分布式ID

使用

注意：

1.字段上需要添加一个注解 : @TableId(type = IdType.AUTO)

2.数据库中id要设置自增长

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

3.2 分页

3.2.1 新建一个MPConfig

因为不推荐在主启动类上写MapperScan，所以挪到配置类上

@Configuration
@MapperScan("cn.kgc.mp.mapper") // 这个地址要写完整,
public class MPConfig {

    // 旧版
  /*  @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }*/

    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

3.2.2 新建ComponentTest

// 分页
@Test
public void testPage() {
    // 泛型等于实体类 == 数据库中的一张表
    // current: 当前页 size表示每页显示条数
    // 注意条件
    Page<User> page = new Page<>(5,2);
    userService.page(page);
    // 1.获取所有数据
    List<User> userList = page.getRecords();
    // 2.总记录数
    long total = page.getTotal();
    // 3.总页数
    long pages = page.getPages();
    // 4.是否有上一页
    boolean previous = page.hasPrevious();
    // 5.是否有下一页
    boolean next = page.hasNext();

    userList.forEach(System.out::println);
    System.out.println("总记录数：" + total);
    System.out.println("总页数：" + pages);
    System.out.println("是否有上一页：" + previous);
    System.out.println("是否有下一页：" + next);
}

3.3 逻辑删除

注意：数据库字段，长度为1

21世纪数据最重要，不是人才

核心：将delete操作改为update操作，每次操作的时候，都会拼接上where条件 is_deleted = 0

数据库的每一张表都对应一个实体类，可以给表加上一个字段 is_deleted

如果结果为1，认为你是删除的，查询的时候带上了这个条件，用户看不到了，对于用户来讲就是删除了

如果结果为0，用户正常查看

根据阿里开发规范：数据库所有is开头的字段，在实体类中都要去掉is

• 在使用的过程中，有两种方式
  • 局部的：添加注解
    • @TableLogic() // 逻辑删除，后面的查询mp都会自动帮你拼接条件 where is_deleted = ？
    • @TableField(“is_deleted”) // 相当于是将字段deleted 跟 数据库 is_deleted 相绑定
      • 其实就是数据库在查询的时候 is_deleted as deleted
  • 全局的：yml中配置

3.3.1 操作

局部

• 在数据库添加is_deleted 字段
• 在实体类中添加deleted属性
• 在deleted属性上添加注解

全局

修改yml文件

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted  # 全局逻辑删除的实体字段名
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

3.4 自动填充

阿里规范中，每一张表至少都需要有三个字段，id，createTime，updateTime

• 在数据库中添加create_time 和 update_time字段

• 在实体类中添加createTime 和updateTime

• 在属性上添加注解

  @TableField(value = "create_time", fill = FieldFill.INSERT)
  private Date createTime; // java.util
  
  @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE) // 在新增的，默认修改时间为新增时间
  private Date updateTime;
  

• 新建一个handler

  @Component // 只有在Spring容器中，才能使用Spring提供的功能
  public class MyMetaObjectHandler implements MetaObjectHandler {
      @Override
      public void insertFill(MetaObject metaObject) {
          // 每一次新增的时候会自动的执行 fieldName = 实体类字段
          this.setFieldValByName("createTime", new Date(), metaObject);
          this.setFieldValByName("updateTime", new Date(), metaObject);
      }
  
      @Override
      public void updateFill(MetaObject metaObject) {
          this.setFieldValByName("updateTime", new Date(), metaObject);
      }
  }
  

3.5 乐观锁

什么是锁？锁的是什么？什么时候用？

注意：数据库字段需要时int，并且长度为1

使用步骤：

• 数据库中添加字段 version int 1
• 实体类中添加属性 version
• 属性上添加注解 @Version
• 配置类中，添加配置 interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

锁 - 资源 - 对象 - 数据

锁 - > 多线程的时候才会用到

• 悲观锁：太重了

  • 代码层面：synchronized
  • 数据库：独占、排他 （表锁、行锁）

• 乐观锁

  • 更新一条记录的时候，希望这条记录没有没有被人更新过

    • 实现 加版本号

    取出记录的时候，获取当前version

    更新的时候，带上这个version

    执行更新的时候 set version = newVersion where version = oldVersion

    version不对，不让更新

UPDATE user SET name=?, age=?, email=?, create_time=?, update_time=?, version=? WHERE id=? AND version=? AND is_deleted=‘0’

4.条件构造器

sql语句有where，条件构造器：自动帮我们拼接where语句

警告:

不支持以及不赞成在 RPC 调用中把 Wrapper 进行传输

不支持将Wapper（条件构造器当成参数进行远程传输）

RPC：远程过程调用，调用远程的方法就像调用本地的一样

1. wrapper 很重
2. 传输 wrapper 可以类比为你的 controller 用 map 接收值(开发一时爽,维护火葬场)
3. 正确的 RPC 调用姿势是写一个 DTO 进行传输,被调用方再根据 DTO 执行相应的操作
4. 我们拒绝接受任何关于 RPC 传输 Wrapper 报错相关的 issue 甚至 pr

DTO

DTO（ Data Transfer Object ）：跟数据库打交道

我们数据库的每一张表，对应一个实体类，表中的每一行数据，对应一个对象

// 表中数据不需要全部显示的时候 select  from 之间我就不需要查询那么多
public class UserDto {
    private Long id;
    private String name;
}

// 一个对象无法去接收某一个查询条件的时候 - 比如 连表查询
public class UserDto {
    private Long id;
    private String name;
    //....
    private Car car
     
}

VO

前端传递的参数 - 使用VO

AbstractWrapper

说明:

QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类
用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件
注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为

• 注意：column 属于数据库字段

1.ge、gt、le、lt、isNull、isNotNull

@Test
public void testDel() {
    /**
         * QueryWrapper<User> wrapper = new QueryWrapper<>();
         * 泛型：User 是一类，对应数据库的一张表
         * 也可以是DTO,只不过能够跟数据库映射的实体类，不需要我们自己写mapper
         */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.isNull("name")
        .ge("age", 10)
        .isNotNull("email");
    int result = userMapper.delete(wrapper);
    System.out.println("受影响行数：" + result);
}

UPDATE user SET is_deleted='1' WHERE is_deleted='0' AND (name IS NULL AND age >= ? AND email IS NOT NULL)

2.eq、ne

@Test
public void testSelect() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name", "胡之欣")
        .ne("age", 18);

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

SELECT id,name,age,email,is_deleted AS deleted,create_time,update_time,version FROM user WHERE is_deleted='0' AND (name = ? AND age <> ?)

3.条件查询 + 分页

http://localhost:8080/mp/page/1/2?key=18

http://localhost:8080 - 确认计算机 + 端口（哪个计算机的tomcat）

mp/page - 请求

1/2 - 参数 当前页/每页显示条数

?key=18 - 问好是传参用的key要跟controller中的key名字一样，不然无法映射

/**
     * rest风格 uri作为资源：一个地址等于一个接口（controller）
     * GetMapping RequestMapper + 访问方式Get
     * current ： 分页所需的参数 - 当前页
     * szie: 分页所需参数 - 每页显示条数
     * key：查询条件，一般是一个对象，以你为浏览器简单演示的时候，传递不方便
     * 返回给前端的是看前端要什么，而不是我们有什么
     */

@GetMapping("page/{current}/{size}")
public Map<String, Object> getUserByKey(@PathVariable Long current, @PathVariable Long size, String key) {
    Map<String, Object> map = new HashMap<>();
    // 1.Page对象 - 分页
    Page<User> page = new Page<>(current, size);
    // 2.Wapper对象 - 查询
    QueryWrapper wrapper = new QueryWrapper();
    // 如果查询条件不为空
    if (StringUtils.isNotBlank(key)) {
        wrapper.eq("age", key);
    }
    // 执行查询
    userService.page(page, wrapper);
    List<User> userList = page.getRecords(); // 所有数据
    long total = page.getTotal();   // 总记录数
    map.put("userList", userList);
    map.put("total", total);
    return map;
}