🍻 正在加载今日诗词....

MyBatisPlus基础

阅读数： 次
原创 字数统计: 5k字   |   预计阅读时长≈ 23分钟

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

了解 MyBatisPlus

MyBatisPlus 介绍

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

官网

愿景

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

image-20211208145121010

代码以及文档

特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

支持数据库

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

  • mysql，oracle，db2，h2，hsql，sqlite，postgresql，sqlserver，Phoenix，Gauss ，clickhouse，Sybase，OceanBase，Firebird，cubrid，goldilocks，csiidb
  • 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库

框架结构

image-20211208145607600

代码托管

Gitee| Github

整合 MyBatis-Plus

准备工作

  • MySQL 5.7 版本及以上。

  • JDK 8。

  • IDEA 2020+。

  • Sql 脚本：

1
2
3
4
-- 创建数据库
CREATE DATABASE IF NOT EXISTS mybatis_plus
DEFAULT CHARACTER SET utf8mb4
DEFAULT COLLATE utf8mb4_general_ci;
1
2
3
4
5
6
7
8
9
10
-- 创建测试表
CREATE TABLE `tb_user` (
	`id` BIGINT ( 20 ) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
	`user_name` VARCHAR ( 20 ) NOT NULL COMMENT '用户名',
	`password` VARCHAR ( 20 ) NOT NULL COMMENT '密码',
	`name` VARCHAR ( 30 ) DEFAULT NULL COMMENT '姓名',
	`age` INT ( 11 ) DEFAULT NULL COMMENT '年龄',
	`email` VARCHAR ( 50 ) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY ( `id` )
) ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4;
1
2
3
4
5
6
-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('1', 'zhangsan', '123456', '张三', '18', 'test1@qq.com');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('2', 'lisi', '123456', '李四', '20', 'test2@qq.com');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('3', 'wangwu', '123456', '王五', '28', 'test3@qq.com');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('4', 'zhaoliu', '123456', '赵六', '21', 'test4@qq.com');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('5', 'sunqi', '123456', '孙七', '24', 'test5@qq.com');

SpringBoot 整合 Mybatis-Plus

首先创建 springboot 项目。

导入相关依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.itjing</groupId>
    <artifactId>mybatis-plus-2021</artifactId>
    <version>1.0.0</version>
    <name>mybatis-plus-2021</name>
    <description>SpringBoot 集成 MyBatisPlus</description>
    <properties>
        <java.version>1.8</java.version>
        <mybatis-plus.version>3.4.3.4</mybatis-plus.version>
    </properties>
    <dependencies>

        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

编写 yml 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 服务器配置
server:
  # 端口
  port: 9999
  servlet:
    # 项目名称
    context-path: /mp
  # tomcat的配置
  tomcat:
    # tomcat的URI编码
    uri-encoding: UTF-8
    # tomcat最大线程数，默认为200
    max-threads: 800
    # Tomcat启动初始化的线程数，默认值25
    min-spare-threads: 30
  max-http-header-size: 65536

spring:
  # 配置数据源
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true
    username: root
    password: root
    # Hikari 连接池配置
    hikari:
      # 最小空闲连接数量
      minimum-idle: 5
      # 空闲连接存活最大时间，默认600000（10分钟）
      idle-timeout: 180000
      # 连接池最大连接数，默认是10
      maximum-pool-size: 1000
      # 此属性控制从池返回的连接的默认自动提交行为,默认值：true
      auto-commit: true
      # 连接池名称
      pool-name: MPHikariCP
      # 此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
      max-lifetime: 1800000
      # 数据库连接超时时间,默认30秒，即30000
      connection-timeout: 30000
      connection-test-query: SELECT 1
      data-source-properties:
        useInformationSchema: true

# MybatisPlus 配置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

编写 POJO

  • User.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.itjing.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lijing
 * @date 2021年12月08日 15:19
 * @description
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {

    /**
     * 主键
     */
    private Long id;

    /**
     * 用户名
     */
    @TableField("user_name")
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 姓名
     */
    private String name;

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

    /**
     * 电子邮件
     */
    private String email;
}

编写 Mapper

  • UserMapper.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.itjing.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itjing.entity.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author lijing
 * @date 2021年12月08日 15:21
 * @description
 */
public interface UserMapper extends BaseMapper<User> {

}

编写启动类

1
2
3
4
5
6
7
@SpringBootApplication
@MapperScan("com.itjing.mapper") //设置mapper接口的扫描包
public class MybatisPlus2021Application {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlus2021Application.class, args);
    }
}

编写测试用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.itjing;

import com.itjing.entity.User;
import com.itjing.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
class MybatisPlus2021ApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }
}

通用 CRUD

概述

  • 通过上面的学习，我们知道通过继承BaseMapper可以实现各种各样的单表操作，下面将详细讲解这些操作。

image-20211208152629160

插入操作

方法定义

1
2
3
4
5
6
/**
 * 插入一条记录
 *
 * @param entity 实体对象
 */
int insert(T entity);

测试用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void testInsert(){
    User user = new User();
    user.setUsername("lijing");
    user.setPassword("123456");
    user.setName("李晶");
    user.setAge(18);
    user.setEmail("123456@qq.com");

    int count = userMapper.insert(user);
    // 数据库受影响的行数
    System.out.println("count = " + count);
    // 自增后的id会回填到对象中
    System.out.println("user.getId() = " + user.getId());
}

测试

结果：

image-20211208153303688

数据库记录：

image-20211208153427278

可以看到，数据已经写入到数据库中了，但是，id 的值是不正确的，我们期望的是数据库自增长，实际是 MP 生成了 id 的值写入到数据库中。

MP 支持的 id 策略：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.baomidou.mybatisplus.annotation;

import lombok.Getter;

/**
 * 生成ID类型枚举类
 *
 * @author hubin
 * @since 2015-11-10
 */
@Getter
public enum IdType {
    /**
     * 数据库ID自增
     * <p>该类型请确保数据库设置了 ID自增 否则无效</p>
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
     */
    NONE(1),
    /**
     * 用户输入ID
     * <p>该类型可以通过自己注册自动填充插件进行填充</p>
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 分配ID (主键类型为number或string）,
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)
     *
     * @since 3.3.0
     */
    ASSIGN_ID(3),
    /**
     * 分配UUID (主键类型为 string)
     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))
     */
    ASSIGN_UUID(4),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}
     */
    @Deprecated
    ID_WORKER_STR(3),
    /**
     * @deprecated 3.3.0 please use {@link #ASSIGN_UUID}
     */
    @Deprecated
    UUID(4);

    private final int key;

    IdType(int key) {
        this.key = key;
    }
}

修改 User 对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {

    /**
     * 主键
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户名
     */
    @TableField("user_name")
    private String username;

    /**
     * 密码
     */
    private String password;

    /**
     * 姓名
     */
    private String name;

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

    /**
     * 电子邮件
     */
    private String email;
}

再次测试，数据是自增长的了。

@TableField 注解

  • 在 MP 中通过@TableField注解可以指定字段的一些属性，常常解决的问题有 2 个：

    • ①对象中的属性名和字段名不一致的问题（非驼峰）。
    • ②对象中的属性字段在表中不存在的问题。

  • 示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {

    /**
     * 主键
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户名
     */
    @TableField("user_name") // 解决字段名不一致
    private String username;

    /**
     * 密码
     */
    @TableField(select = false) // 该字段不加入到查询中
    private String password;

    /**
     * 姓名
     */
    private String name;

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

    /**
     * 电子邮件
     */
    private String email;

    @TableField(exist = false)
    private String address; // 该字段在数据库表中不存在
}

更新操作

概述

在 MyBatisPlus 中，更新操作有 2 种，一种是根据 id 更新，另一种是根据条件更新。

根据 id 更新

方法定义：

1
2
3
4
5
6
/**
 * 根据 ID 修改
 *
 * @param entity 实体对象（对象属性可以为null）
 */
int updateById(@Param(Constants.ENTITY) T entity);

测试：

1
2
3
4
5
6
7
8
9
10
11
@Test
public void testUpdateById() {

    User user = new User();
    user.setId(1L);
    user.setUsername("zs");

    // 根据id更新，更新不为null的字段，即有效字段更新，返回更新的条数
    int result = userMapper.updateById(user);
    System.out.println("result = " + result);
}

根据条件更新

方法定义：

1
2
3
4
5
6
7
/**
 * 根据 Wrapper 条件，更新记录
 *
 * @param entity        实体对象 (set 条件值,可以为 null)
 * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
 */
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test
public void testUpdate() {
    // 封装更新字段的对象
    User user = new User();
    user.setAge(18);

    // 封装更新条件的对象
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("user_name", "lijing");

    int result = userMapper.update(user, queryWrapper);
    System.out.println("result = " + result);
}

@Test
public void testUpdate2() {
    UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
    updateWrapper.set("age", 18)
        .set("password", "123456")
        .eq("user_name", "zhangsan");

    int result = userMapper.update(null, updateWrapper);
    System.out.println("result = " + result);
}

删除操作

deleteById

方法定义：

1
2
3
4
5
6
/**
 * 根据 ID 删除
 *
 * @param id 主键ID
 */
int deleteById(Serializable id);

测试：

1
2
3
4
5
6
@Test
public void testDeleteById(){
    // 执行删除操作
    int result = userMapper.deleteById(5);
    System.out.println("result = " + result);
}

deleteByMap

方法定义：

1
2
3
4
5
6
/**
 * 根据 columnMap 条件，删除记录
 *
 * @param columnMap 表字段 map 对象
 */
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

测试：

1
2
3
4
5
6
7
8
9
10
@Test
public void testDeleteByMap(){
    Map<String,Object> map = new HashMap<>();
    map.put("id", "5");
    map.put("age", "24");

    // 将map中的元素设置为删除的条件，多个条件之间是and的关系
    int result = userMapper.deleteByMap(map);
    System.out.println("result = " + result);
}

delete

方法定义：

1
2
3
4
5
6
/**
 * 根据条件，删除记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
 */
int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试：

1
2
3
4
5
6
@Test
public void testDelete() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.gt("age", 20);
    userMapper.delete(queryWrapper);
}

deleteBatchIds

方法定义：

1
2
3
4
5
6
/**
 * 删除（根据ID 批量删除）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

测试：

1
2
3
4
5
6
@Test
public void testDeleteBatchIds() {
    // 根据id集合批量删除
    int result = userMapper.deleteBatchIds(Arrays.asList(1, 2, 3));
    System.out.println("result = " + result);
}

查询操作

概述

MyBatisPlus 提供了多种查询操作，包括根据 id 查询、批量查询、查询单条数据、查询列表、分页查询等操作。

selectById

方法定义：

1
2
3
4
5
6
/**
 * 根据 ID 查询
 *
 * @param id 主键ID
 */
T selectById(Serializable id);

测试：

1
2
3
4
5
6
@Test
public void testSelectById(){
    // 根据id查询数据
    User user = userMapper.selectById(1);
    System.out.println("user = " + user);
}

selectBatchIds

方法定义：

1
2
3
4
5
6
/**
 * 查询（根据ID 批量查询）
 *
 * @param idList 主键ID列表(不能为 null 以及 empty)
 */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

测试：

1
2
3
4
5
6
@Test
public void testSelectBatchIds() {
    // 根据id集合批量查询
    List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    System.out.println("userList = " + userList);
}

selectOne

方法定义：

1
2
3
4
5
6
/**
 * 根据条件，查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试：

1
2
3
4
5
6
7
8
9
@Test
public void testSelectOne() {
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.eq(User::getUsername, "zhangsan");

    // 根据条件查询一条数据，如果结果超过一条则报错
    User user = userMapper.selectOne(lambdaQueryWrapper);
    System.out.println("user = " + user);
}

selectList

方法定义：

1
2
3
4
5
6
/**
 * 根据条件，查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试：

1
2
3
4
5
6
7
8
@Test
public void testSelectList() {
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.ge(User::getId, 3);
    // 根据条件查询数据
    List<User> userList = userMapper.selectList(lambdaQueryWrapper);
    System.out.println("userList = " + userList);
}

selectCount

方法定义：

1
2
3
4
5
6
/**
 * 根据条件，查询总记录数
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

测试：

1
2
3
4
5
6
@Test
public void testSelectCount() {
    // 根据条件查询数据条数
    Long count = userMapper.selectCount(new LambdaQueryWrapper<User>().ge(User::getId, 2));
    System.out.println("count = " + count);
}

selectPage

方法定义：

1
2
3
4
5
6
7
/**
 * 根据条件，查询全部记录（并翻页）
 *
 * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
<P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

使用分页，首先要配置分页插件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.itjing.config;

import com.baomidou.mybatisplus.annotation.DbType;
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;

/**
 * @author lijing
 * @date 2021年12月08日 16:22
 * @description MybatisPlus配置类
 */
@Configuration
public class MybatisPlusConfig {

    /**
     * 配置分页插件
     * @return
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void testSelectPage(){
    // 分页
    Page<User> page = new Page<>(1,3);
    // 查询分页数据，后面的 QueryWrapper，可以自己设置查询条件
    Page<User> selectPage = userMapper.selectPage(page, new QueryWrapper<>());
    long total = selectPage.getTotal();
    long pages = selectPage.getPages();
    System.out.println("数据总条数 = " + total);
    System.out.println("总页数 = " + pages);
    List<User> userList = selectPage.getRecords();
    System.out.println("userList = " + userList);
}

Mybatis Plus 的配置

在 MyBatisPlus 中有大量的配置，其中有一部分是 Mybatis 原生的配置，另一部分是 MyBatisPlus 的配置。

基本配置

configLocation

MyBatis 配置文件位置，如果有单独的 MyBatis 配置，将其路径配置到 configLocation 中。

1
2
mybatis-plus:
  config-location: classpath:mybatis-config.xml

mapperLocations

Mybatis Mapper 所对应的 XML 文件配置，如果在 Mapper 中有自定义方法（XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。

1
2
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml

typeAliasesPackage

Mybatis 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）。

1
2
mybatis-plus:
  type-aliases-package: com.itjing.entity

进阶配置

mapUnderscoreToCamelCase

  • mapUnderscoreToCamelCase

    • 类型：boolean。
    • 默认值：true。

  • 是否开启自动驼峰命名规则的映射，即从经典数据库列名 A_COLUMN（下划线命名）到经典的 Java 属性名 AColumn 的类似映射。

注意：

  • 此属性在 Mybatis 中的原默认值为 false，在 MybatisPlux 中，此属性也将用于生成最终的 SQL 的 select body。

  • 如果数据库命名符合规则则无需使用@TableField 注解指定数据库字段名。

1
2
3
4
mybatis-plus:
  configuration:
    # 关闭自动驼峰映射，该参数不能和mybatis-plus.config-location同时存在，默认值为true，一般情况下，默认即可
    map-underscore-to-camel-case: false

cacheEnabled

  • cacheEnabled:

    • 类型：boolean。
    • 默认值：true。

  • 全局的开启或关闭配置文件中的所有映射器已经配置的任何缓存，默认为 true。

1
2
3
4
mybatis-plus:
  configuration:
    # 全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，默认为 true，一般情况下，默认即可
    cacheEnabled: false

DB 策略配置

idType

  • idType：

    • 类型：com.baomidou.mybatisplus.annotation.IdType。
    • 默认值：ASSIGN_ID。

  • 全局设置主键类型，设置后，即可省略实体对象中的@TableId(type=IdType.AUTO)配置。

1
2
3
4
mybatis-plus:
  global-config:
    db-config:
      id-type: auto

tablePrefix

  • tablePrefix：

    • 类型：String。
    • 默认值：null。

  • 表名前缀，全局配置后可省略@TableName()的配置。

1
2
3
4
mybatis-plus:
  global-config:
    db-config:
      table-prefix: tb_

条件构造器

概述

在 MyBatisPlus 中，Wrapper接口的实现类关系如下：

image-20211208164353220

可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，我们重点学习AbstractWrapper及其实现子类。

说明：QueryWrapper(LambdaQueryWrapper)和 UpdateWrapper(LambdaUpdateWrapper)的父类用于生成 sql 的 where 条件, entity 属性也用于生成 sql 的 where 条件。

注意：entity 生成的 where 条件与使用各个 api 生成的 where 条件没有任何关联行为。

allEq

说明

1
allEq(Map<R, V> params)
1
allEq(Map<R, V> params, boolean null2IsNull)
1
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

参数说明：

  • params：key 是数据库字段名，value 为字段值。

  • null2IsNull：为 true 则在 map 的 value 为 null 时调用 isNull 方法，为 false 时则忽略 value 为 null。

应用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Test
public void testAllEq() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();

    // 设置条件
    Map<String,Object> params = new HashMap<>();
    params.put("name","zhangsan");
    params.put("age", null);

    // SELECT id,user_name,password,name,age,email FROM tb_user WHERE (name = ? AND age IS NULL)
    wrapper.allEq(params);

    List<User> userList = userMapper.selectList(wrapper);
    System.out.println("userList = " + userList);
}

@Test
public void testAllEqNull2IsNullFalse() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();

    // 设置条件
    Map<String,Object> params = new HashMap<>();
    params.put("name","zhangsan");
    params.put("age", null);

    // SELECT id,user_name,password,name,age,email FROM tb_user WHERE (name = ?)
    wrapper.allEq(params,false);

    List<User> userList = userMapper.selectList(wrapper);
    System.out.println("userList = " + userList);
}

基本操作比较

  • eq：等于=

  • ne：不等于<>

  • gt：大于>

  • lt：小于<

  • ge：大于等于>=

  • le：小于等于le

  • between：between 值1 AND 值2

  • notBetween：NOT between 值1 AND 值2

  • in：字段 IN (值1,值2,...)

  • notIn：字段 NOT IN (值1,值2,...)

模糊查询

  • like：

    • LIKE ‘%值%’。
    • 例: like("name", "王")—>name like '%王%'

  • notlike：

    • NOT LIKE ‘%值%’。
    • 例: notLike("name", "王")—>name not like '%王%'

  • likeLeft：

    • LIKE ‘%值’。
    • 例: likeLeft("name", "王")—>name like '%王'

  • LikeRight：

    • LIKE ‘值%’。
    • 例: likeRight("name", "王")—>name like '王%'

排序

  • orderBy：

    • 排序：ORDER BY 字段, …
    • 例: orderBy(true, true, "id", "name")—>order by id ASC,name ASC

  • orderByAsc：

    • 排序：ORDER BY 字段, … ASC。
    • 例: orderByAsc("id", "name")—>order by id ASC,name ASC

  • orderByDesc：

    • 排序：ORDER BY 字段, … DESC。
    • 例: orderByDesc("id", "name")—>order by id DESC,name DESC

逻辑查询

  • or：

    • 拼接 OR。
    • 例: eq("id",1).or().eq("name","老王")—>id = 1 or name = '老王'

  • and：

    • AND 嵌套。
    • 例: and(i -> i.eq("name", "李白").ne("status", "活着"))—>and (name = '李白' and status <> '活着')

select

select：设置查询字段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void testSelectWrapper() {
    QueryWrapper<User> wrapper = new QueryWrapper<>();

    // SELECT user_name,age,password FROM tb_user WHERE (name = ? OR age = ?)
    wrapper
        .eq("name", "张三")
        .or()
        .eq("age", 18)
        .select("user_name", "age", "password");

    List<User> userList = this.userMapper.selectList(wrapper);
    System.out.println("userList = " + userList);
}
本文作者： LiJing
发布时间： 2021-12-08
最后更新： 2024-06-24
本文标题： MyBatisPlus基础
本文链接： https://blog-yilia.xiaojingge.com/posts/f4b9a74f.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信
本站总访问量次 | 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

喜欢看书、打代码、吃吃吃！我从没被谁知道，所以也没被谁忘记。在别人的回忆中生活，并不是我的目的。我只不过是自己一个人在努力罢了。