简介

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

简介也就一句话的事，具体的大家还是去看挂=官网吧。总的说， MP 是对 MyBatis的升级，保留了MyBatis原来的全部内容。

特性

无侵入: 只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

损耗小: 启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作

强大的 CRUD 操作: 内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求

支持 Lambda 形式调用: 通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错

支持多种数据库: 支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多种数据库

支持主键自动生成: 支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题

支持 XML 热加载: Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动

支持 ActiveRecord 模式: 支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作

支持自定义全局通用操作: 支持全局通用方法注入（ Write once, use anywhere ）

支持关键词自动转义: 支持数据库关键词（order、key......）自动转义，还可自定义关键词

内置代码生成器: 采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用

内置分页插件: 基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询

内置性能分析插件: 可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

内置全局拦截插件: 提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

内置 Sql 注入剥离器: 支持 Sql 注入剥离，有效预防 Sql 注入攻击

开始入门

入门其实很简单。我们首先准备数据源，准备好依赖。一步一步来: 数据库创建:

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

数据的话，大家自己插入几条数据，我这就不插入数据了:

我们现在需要添加我们的 mybatis-plus 的依赖:

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

我们在 entity/model 层去写我们的实体类:

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

这里我用到了 lombok , 这个就不向大家介绍了。

现在开始写我们的 dao 层 ，有的地方叫 mapper 层，我这里就不写 mapper 层了，我就不写什么 .xml 的 mapper 配置文件了，我这里就用注解的形式来做一个简单的入门。

@Mapper
public interface UserDAO {
    @Select("select * from user")
    List<User> findAll();
}

我们在 service 里面去实现一下这个方法就好了，再在我们的 controller 里面去调用 service 。这里呢，我们可以在控制台去看到我们的sql语句，用这个:

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

这就是一个简单的入门。

CRUB 的使用

Insert 的插入操作

@RunWith(SpringRunner.class)
@SpringBootTest
public class CRUDTests {
    @Autowired
    private UserService userService;

    @Test
    public void testInsert(){

        User user = new User();
        user.setName("Helen");
        user.setAge(18);
        user.setEmail("123456789@qq.com");

        int result = userService.insert(user);
        // 影响的行数
        System.out.println(result);
        // id自动回填
        System.out.println(user);
    }
}

主键策略

Plus默认的主键策略是：ID_WORKER

MyBatis-Plus 默认的主键策略是： ID_WORKER 全局唯一ID

主键自增

• 要想主键自增需要配置如下主键策略
• 需要在创建数据表的时候设置主键自增
• 实体字段中配置 @TableId(type = IdType.AUTO)

@TableId(type = IdType.AUTO)
private Long id;

但是这个呢，似乎不加这个也可以实现主键的自增。我在用MyBatis的时候就没加这个：

@Insert({"insert into user (`name` , `age` ,`email` VALUES (#{name},#{age},#{email})"})
@Options(useGeneratedKeys = true, keyColumn = "id" , keyProperty = "id")
public void insert(TaskNodeRecord taskNodeRecord);

这样写也可以。

我们要是想影响到所有的主键配置，就需要在配置中加入这个:

# 全局设置主键生成策略
mybatis-plus:
  global-config:
    db-config:
      id-type: auto

我们可以看下这个里面其他的主键的策略，看源码就知道了:

@Getter
public enum IdType {
    /**
     * 数据库ID自增
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型
     */
    NONE(1),
    /**
     * 用户输入ID
     * 该类型可以通过自己注册自动填充插件进行填充
     */
    INPUT(2),

    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
    /**
     * 全局唯一ID (idWorker)
     */
    ID_WORKER(3),
    /**
     * 全局唯一ID (UUID)
     */
    UUID(4),
    /**
     * 字符串全局唯一ID (idWorker 的字符串表示)
     */
    ID_WORKER_STR(5);

    private int key;

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

Update

我们在 UserDAO 里面直接写一个，这里根据 id 来进行更新:

@Update("update user set `name` = #{name} where `id` = #{id}")
void update(User user);

那要是我们遇到了时间的字段呢？比如说 created_at / uodate_at , 这个时间字段其实在数据库是可以设置自动更新的，这个就不需要我们去操心了，所以我们的使用的时候，在 model 里面也不需要增加这个 created_at / update_at 两个字段信息了。

乐观锁

主要适用场景：当要更新一条记录的时候，希望这条记录没有被别人更新，也就是说实现线程安全的数据更新

这个乐观锁的实现方式是什么呢?

• 取出记录时，获取当前version
• 更新时，带上这个version
• 执行更新时， set version = newVersion where version = oldVersion
• 如果version不对，就更新失败

现在我们需要添加这个 version 字段:

ALTER TABLE `user` ADD COLUMN `version` INT

再在实体类中添加 version 字段

@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;

在借口里面添加这个默认值

@Override
public void insertFill(MetaObject metaObject) {
    ......
    this.setFieldValByName("version", 1, metaObject);
}

说明

• 支持的数据类型只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime
• 整数类型下 newVersion = oldVersion + 1
• newVersion 会回写到 entity 中
• 仅支持 updateById(id) 与 update(entity, wrapper) 方法
• 在 update(entity, wrapper) 方法下, wrapper 不能复用

我们需要在配置文件里卖弄无配置一下这个乐观锁:

@EnableTransactionManagement
@Configuration
@MapperScan("com.venus.edu.mapper")
public class MybatisPlusConfig {
    /**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

Select

注解的形式如下:

@Select("select * from user")

mapper 就需要自己到 xxxMapper.xml 里面去写那个语句了。

分页

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

/**
 * 分页插件
 */
@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}

对分页的测试:

@Test
public void testSelectPage() {

    Page<User> page = new Page<>(1,5);
    userMapper.selectPage(page, null);

    page.getRecords().forEach(System.out::println);
    System.out.println(page.getCurrent());
    System.out.println(page.getPages());
    System.out.println(page.getSize());
    System.out.println(page.getTotal());
    System.out.println(page.hasNext());
    System.out.println(page.hasPrevious());
}

我们也可以实时这个 selectMapPage 方法。

Delete

这个和 select 一样，就不多说。

性能分析

性能分析拦截器，用于输出每条 SQL 语句及其执行时间

SQL 性能执行分析,开发环境使用，超过指定时间，停止运行。有助于发现问题

配置插件

参数说明

• maxTime： SQL 执行最大时长，超过自动停止运行，有助于发现问题。
• format： SQL是否格式化，默认false。

Config配置

我们在MybatisConfig 里面配置如下:

/**
 * SQL 执行性能分析插件
 * 开发环境使用，线上不推荐。 maxTime 指的是 sql 最大执行时长
 * 设置 dev test 环境开启
 */
@Bean
@Profile({"dev","test"})
public PerformanceInterceptor performanceInterceptor() {
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(100);//ms，超过此处设置的ms则sql不执行
    performanceInterceptor.setFormat(true);
    return performanceInterceptor;
}

SpringBoot 设置 dev 环境

# 环境设置：dev、test、prod
spring:
  profiles:
    active: dev

测试

/**
 * 测试 性能分析插件
 */
@Test
public void testPerformance() {
    User user = new User();
    user.setName("我是Helen");
    user.setEmail("helen@sina.com");
    user.setAge(18);
    userService.insert(user);
}

条件构造器

• Wrapper ： 条件构造抽象类，最顶端父类
• AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
• QueryWrapper ： Entity 对象封装操作类，不是用 lambda 语法
• UpdateWrapper ： Update 条件封装，用于 Entity 对象更新操作
• AbstractLambdaWrapper ： Lambda 语法使用 Wrapper 统一处理解析 lambda 获取 column。
• LambdaQueryWrapper ：看名称也能明白就是用于 Lambda语法使用的查询 Wrapper
• LambdaUpdateWrapper ： Lambda 更新封装 Wrapper

@RunWith(SpringRunner.class)
@SpringBootTest
public class QueryWrapperTests {
    @Autowired
    private UserMapper userMapper;
}

AbstractWrapper

ge、gt、le、lt、isNull、isNotNull

@Test
public void testDelete() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .isNull("name")
        .ge("age", 12)
        .isNotNull("email");
    int result = userMapper.delete(queryWrapper);
    System.out.println("delete return count = " + result);
}

相当于：

UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL

eq、ne

@Test
public void testSelectOne() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("name", "Tom");

    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);
}

相当于:

SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND name = ?

between、notBetween

包含大小边界

@Test
public void testSelectCount() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.between("age", 20, 30);

    Integer count = userMapper.selectCount(queryWrapper);
    System.out.println(count);
}

相当于:

SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ?

allEq

@Test
public void testSelectList() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    Map<String, Object> map = new HashMap<>();
    map.put("id", 2);
    map.put("name", "Jack");
    map.put("age", 20);

    queryWrapper.allEq(map);
    List<User> users = userMapper.selectList(queryWrapper);

    users.forEach(System.out::println);
}

相当于:

SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 AND name = ? AND id = ? AND age = ?

like、notLike、likeLeft、likeRight

@Test
public void testSelectMaps() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper
        .notLike("name", "e")
        .likeRight("email", "t");

    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
    maps.forEach(System.out::println);
}

相当于:

SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ?

in、notIn、inSql、notinSql、exists、notExists

in、notIn：

• notIn("age",{1,2,3})--->age not in (1,2,3)
• notIn("age", 1, 2, 3)--->age not in (1,2,3)

inSql、notinSql：可以实现子查询

• 例: inSql("age", "1,2,3,4,5,6")--->age in (1,2,3,4,5,6)
• 例: inSql("id", "select id from table where id < 3")--->id in (select id from table where id < 3)@Test public void testSelectObjs() { QueryWrapper<User> queryWrapper = new QueryWrapper<>(); //queryWrapper.in("id", 1, 2, 3); queryWrapper.inSql("id", "select id from user where id < 3"); List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表 objects.forEach(System.out::println); } 相当于:SELECT id,name,age,email,create_time,update_time,deleted,version FROM user WHERE deleted=0 AND id IN (select id from user where id < 3) or、and注意：这里使用的是 UpdateWrapper

不调用or则默认为使用 and 连

@Test
public void testUpdate1() {

    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");

    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or()
        .between("age", 20, 30);

    int result = userMapper.update(user, userUpdateWrapper);

    System.out.println(result);
}

相当于:

UPDATE user SET name=?, age=?, update_time=? WHERE deleted=0 AND name LIKE ? OR age BETWEEN ? AND ?

嵌套or、嵌套and

@Test
public void testUpdate2() {
    //修改值
    User user = new User();
    user.setAge(99);
    user.setName("Andy");
    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .or(i -> i.eq("name", "李白").ne("age", 20));

    int result = userMapper.update(user, userUpdateWrapper);
    System.out.println(result);
}

相当于:

UPDATE user SET name=?, age=?, update_time=?
WHERE deleted=0 AND name LIKE ?
OR ( name = ? AND age <> ? )

orderBy、orderByDesc、orderByAsc

@Test
public void testSelectListOrderBy() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.orderByDesc("id");

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

相当于:

SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 ORDER BY id DESC

last

直接拼接到 sql 的最后

注意：只能调用一次,多次调用以最后一次为准 有sql注入的风险,请谨慎使用

@Test
public void testSelectListLast() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.last("limit 1");

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

相当于:

SELECT id,name,age,email,create_time,update_time,deleted,version
FROM user WHERE deleted=0 limit 1

指定要查询的列

@Test
public void testSelectListColumn() {

    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.select("id", "name", "age");

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

相当于:

SELECT id,name,age FROM user WHERE deleted=0

set、setSql

最终的sql会合并 user.setAge()，以及 userUpdateWrapper.set() 和 setSql() 中 的字段

@Test
public void testUpdateSet() {

    //修改值
    User user = new User();
    user.setAge(99);

    //修改条件
    UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
    userUpdateWrapper
        .like("name", "h")
        .set("name", "老李头")//除了可以查询还可以使用set设置修改的字段
        .setSql(" email = '123@qq.com'");//可以有子查询

    int result = userMapper.update(user, userUpdateWrapper);
}

相当于:

UPDATE user SET age=?, update_time=?, name=?, email = '123@qq.com' WHERE deleted=0 AND name LIKE ?