快速入门

创建一个Spring Boot项目。

导入依赖

<dependencies>  
           <dependency>  
               <groupId>org.springframework.boot</groupId>  
               <artifactId>spring-boot-starter</artifactId>  
           </dependency>  
           <dependency>  
               <groupId>org.springframework.boot</groupId>  
               <artifactId>spring-boot-starter-test</artifactId>  
               <scope>test</scope>  
           </dependency>  
           <dependency>  
               <groupId>org.springframework.boot</groupId>  
               <artifactId>spring-boot-configuration-processor</artifactId>  
           </dependency>  
           <dependency>  
               <groupId>com.baomidou</groupId>  
               <artifactId>mybatis-plus-boot-starter</artifactId>  
               <version>3.4.2</version>  
           </dependency>  
           <dependency>  
               <groupId>mysql</groupId>  
               <artifactId>mysql-connector-java</artifactId>  
               <scope>runtime</scope>  
           </dependency>  
           <dependency>  
               <groupId>org.projectlombok</groupId>  
               <artifactId>lombok</artifactId>  
           </dependency>  
       </dependencies>

配置数据库

spring:  
     datasource:  
       driver-class-name: com.mysql.cj.jdbc.Driver  
       url: jdbc:mysql://localhost:3306/yogurt?serverTimezone=Asia/Shanghai  
       username: root  
       password: root  
   mybatis-plus:  
     configuration:  
       log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启SQL语句打印

创建一个实体类

package com.example.mp.po;  
   import lombok.Data;  
   import java.time.LocalDateTime;  
   @Data  
   public class User {  
    private Long id;  
    private String name;  
    private Integer age;  
    private String email;  
    private Long managerId;  
    private LocalDateTime createTime;  
   }

创建一个mapper接口

package com.example.mp.mappers;  
   import com.baomidou.mybatisplus.core.mapper.BaseMapper;  
   import com.example.mp.po.User;  
   public interface UserMapper extends BaseMapper<User> { }

在SpringBoot启动类上配置mapper接口的扫描路径

package com.example.mp;  
   import org.mybatis.spring.annotation.MapperScan;  
   import org.springframework.boot.SpringApplication;  
   import org.springframework.boot.autoconfigure.SpringBootApplication;  
   @SpringBootApplication  
   @MapperScan("com.example.mp.mappers")  
   public class MybatisPlusApplication {  
    public static void main(String[] args) {  
     SpringApplication.run(MybatisPlusApplication.class, args);  
    }  
   }

在数据库中创建表

DROP TABLE IF EXISTS user;  
   CREATE TABLE user (  
   id BIGINT(20) PRIMARY KEY NOT NULL COMMENT '主键',  
   name VARCHAR(30) DEFAULT NULL COMMENT '姓名',  
   age INT(11) DEFAULT NULL COMMENT '年龄',  
   email VARCHAR(50) DEFAULT NULL COMMENT '邮箱',  
   manager_id BIGINT(20) DEFAULT NULL COMMENT '直属上级id',  
   create_time DATETIME DEFAULT NULL COMMENT '创建时间',  
   CONSTRAINT manager_fk FOREIGN KEY(manager_id) REFERENCES user (id)  
   ) ENGINE=INNODB CHARSET=UTF8;  
   INSERT INTO user (id, name, age ,email, manager_id, create_time) VALUES  
   (1, '大BOSS', 40, 'boss@baomidou.com', NULL, '2021-03-22 09:48:00'),  
   (2, '李经理', 40, 'boss@baomidou.com', 1, '2021-01-22 09:48:00'),  
   (3, '黄主管', 40, 'boss@baomidou.com', 2, '2021-01-22 09:48:00'),  
   (4, '吴组长', 40, 'boss@baomidou.com', 2, '2021-02-22 09:48:00'),  
   (5, '小菜', 40, 'boss@baomidou.com', 2, '2021-02-22 09:48:00')

编写一个SpringBoot测试类

package com.example.mp;  
   import com.example.mp.mappers.UserMapper;  
   import com.example.mp.po.User;  
   import org.junit.Test;  
   import org.junit.runner.RunWith;  
   import org.springframework.beans.factory.annotation.Autowired;  
   import org.springframework.boot.test.context.SpringBootTest;  
   import org.springframework.test.context.junit4.SpringRunner;  
   import java.util.List;  
   import static org.junit.Assert.*;  
   @RunWith(SpringRunner.class)  
   @SpringBootTest  
   public class SampleTest {  
    @Autowired  
    private UserMapper mapper;  
    @Test  
    public void testSelect() {  
     List<User> list = mapper.selectList(null);  
     assertEquals(5, list.size());  
     list.forEach(System.out::println);  
    }  
   }

项目结构图如下：

运行测试类

可以看到，针对单表的基本CRUD操作，只需要创建好实体类，并创建一个继承自 BaseMapper 的接口即可，可谓非常简洁。并且，我们注意到，User 类中的 managerId ，createTime 属性，自动和数据库表中的 manager_id ，create_time 对应了起来，这是因为mp自动做了数据库下划线命名，到Java类的驼峰命名之间的转化。

核心功能

注解

mp一共提供了8个注解，这些注解是用在Java的实体类上面的

@TableName

注解在类上，指定类和数据库表的映射关系。实体类的类名（转成小写后）和数据库表名相同时，可以不指定该注解。

@TableId

注解在实体类的某一字段上，表示这个字段对应数据库表的主键。当主键名为id时（表中列名为id，实体类中字段名为id），无需使用该注解显式指定主键，mp会自动关联。若类的字段名和表的列名不一致，可用 value 属性指定表的列名。另，这个注解有个重要的属性 type ，用于指定主键策略。

@TableField

注解在某一字段上，指定Java实体类的字段和数据库表的列的映射关系。这个注解有如下几个应用场景。

排除非表字段

若Java实体类中某个字段，不对应表中的任何列，它只是用于保存一些额外的，或组装后的数据，则可以设置 exist 属性为 false ，这样在对实体对象进行插入时，会忽略这个字段。排除非表字段也可以通过其他方式完成，如使用 static 或 transient 关键字，但个人觉得不是很合理，不做赘述

字段验证策略

通过 insertStrategy ， updateStrategy ， whereStrategy 属性进行配置，可以控制在实体对象进行插入，更新，或作为WHERE条件时，对象中的字段要如何组装到SQL语句中。

字段填充策略

通过 fill 属性指定，字段为空时会进行自动填充

@Version

乐观锁注解

@EnumValue

注解在枚举字段上

@TableLogic

逻辑删除

KeySequence

序列主键策略（ oracle ）

InterceptorIgnore

插件过滤规则

CRUD接口

mp封装了一些最基础的CRUD方法，只需要直接继承mp提供的接口，无需编写任何SQL，即可食用。mp提供了两套接口，分别是Mapper CRUD接口和Service CRUD接口。并且mp还提供了条件构造器 Wrapper ，可以方便地组装SQL语句中的WHERE条件。

Mapper CRUD接口

只需定义好实体类，然后创建一个接口，继承mp提供的 BaseMapper ，即可食用。mp会在mybatis启动时，自动解析实体类和表的映射关系，并注入带有通用CRUD方法的mapper。 BaseMapper 里提供的方法，部分列举如下：

insert(T entity) 插入一条记录

deleteById(Serializable id) 根据主键id删除一条记录

delete(Wrapper wrapper) 根据条件构造器wrapper进行删除

selectById(Serializable id) 根据主键id进行查找

selectBatchIds(Collection idList) 根据主键id进行批量查找

selectByMap(Map<String,Object> map) 根据map中指定的列名和列值进行等值匹配查找

selectMaps(Wrapper wrapper) 根据 wrapper 条件，查询记录，将查询结果封装为一个Map，Map的key为结果的列，value为值

selectList(Wrapper wrapper) 根据条件构造器wrapper进行查询

update(T entity, Wrapper wrapper) 根据条件构造器wrapper进行更新

updateById(T entity)

…

下面是几个比较特别的方法

selectMaps

BaseMapper 接口还提供了一个 selectMaps 方法，这个方法会将查询结果封装为一个Map，Map的key为结果的列，value为值

该方法的使用场景如下：

只查部分列

当某个表的列特别多，而SELECT的时候只需要选取个别列，查询出的结果也没必要封装成Java实体类对象时（只查部分列时，封装成实体后，实体对象中的很多属性会是null），则可以用 selectMaps ，获取到指定的列后，再自行进行处理即可

@Test  
public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  wrapper.select("id","name","email").likeRight("name","黄");  
  List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);  
  maps.forEach(System.out::println);  
}

进行数据统计

// 按照直属上级进行分组，查询每组的平均年龄，最大年龄，最小年龄  
  /**  
  select avg(age) avg_age ,min(age) min_age, max(age) max_age from user group by manager_id having sum(age) < 500;  
  **/  
  @Test  
  public void test3() {  
   QueryWrapper<User> wrapper = new QueryWrapper<>();  
   wrapper.select("manager_id", "avg(age) avg_age", "min(age) min_age", "max(age) max_age")  
     .groupBy("manager_id").having("sum(age) < {0}", 500);  
   List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);  
   maps.forEach(System.out::println);  
  }

selectObjs

只会返回第一个字段（第一列）的值，其他字段会被舍弃
@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  wrapper.select("id", "name").like("name", "黄");  
  List<Object> objects = userMapper.selectObjs(wrapper);  
  objects.forEach(System.out::println);  
 }

得到的结果，只封装了第一列的id

selectCount

查询满足条件的总数，注意，使用这个方法，不能调用 QueryWrapper 的 select 方法设置要查询的列了。这个方法会自动添加 select count(1)

@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  wrapper.like("name", "黄");  
  Integer count = userMapper.selectCount(wrapper);  
  System.out.println(count);  
 }

Service CRUD 接口

说明:

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页前缀命名方式区分 Mapper 层避免混淆，

泛型 T 为任意实体对象

建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承Mybatis-Plus 提供的基类

官网地址：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

a>IService

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑

详情查看源码IService和ServiceImpl

b>创建Service接口和实现类

/*** UserService继承IService模板提供的基础功能 */ 
public interface UserService extends IService<User> {
 }

/**
* ServiceImpl实现了IService，提供了IService中基础功能的实现 
* 若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现 
*/ 
@Service 
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { 
}

c>测试查询记录数

@Autowired 
private UserService userService; 
@Test 
public void testGetCount(){ 
  long count = userService.count(); 
  System.out.println("总记录数：" + count); 
}

d>测试批量插入

@Test 
public void testSaveBatch(){ 
  // SQL长度有限制，海量数据插入单条SQL无法实行， 
  // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper 
  ArrayList<User> users = new ArrayList<>(); 
  for (int i = 0; i < 5; i++) { 
  User user = new User(); 
  user.setName("ybc" + i); 
  user.setAge(20 + i); 
  users.add(user); 
  }
  //SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? ) 
  userService.saveBatch(users); 
}

条件构造器

mp让我觉得极其方便的一点在于其提供了强大的条件构造器 Wrapper ，可以非常方便的构造WHERE条件。条件构造器主要涉及到3个类， AbstractWrapper 。 QueryWrapper ， UpdateWrapper ，它们的类关系如下

在 AbstractWrapper 中提供了非常多的方法用于构建WHERE条件，而 QueryWrapper 针对 SELECT 语句，提供了 select() 方法，可自定义需要查询的列，而 UpdateWrapper 针对 UPDATE 语句，提供了 set() 方法，用于构造 set 语句。条件构造器也支持lambda表达式，写起来非常舒爽。

下面对 AbstractWrapper 中用于构建SQL语句中的WHERE条件的方法进行部分列举

eq ：equals，等于

allEq ：all equals，全等于

ne ：not equals，不等于

gt ：greater than ，大于 >

ge ：greater than or equals，大于等于 ≥

lt ：less than，小于 <

le ：less than or equals，小于等于 ≤

between ：相当于SQL中的BETWEEN

notBetween

like ：模糊匹配。 like(“name”,“黄”) ，相当于SQL的 name like ‘%黄%’

likeRight ：模糊匹配右半边。 likeRight(“name”,“黄”) ，相当于SQL的 name like ‘黄%’

likeLeft ：模糊匹配左半边。 likeLeft(“name”,“黄”) ，相当于SQL的 name like ‘%黄’

notLike ： notLike(“name”,“黄”) ，相当于SQL的 name not like ‘%黄%’

isNull

isNotNull

and ：SQL连接符AND

or ：SQL连接符OR

apply ：用于拼接SQL，该方法可用于数据库函数，并可以动态传参

…

使用示例

下面通过一些具体的案例来练习条件构造器的使用。（使用前文创建的 user 表）

// 案例先展示需要完成的SQL语句，后展示Wrapper的写法  
// 1. 名字中包含佳，且年龄小于25  
// SELECT * FROM user WHERE name like '%佳%' AND age < 25  
QueryWrapper<User> wrapper = new QueryWrapper<>();  
wrapper.like("name", "佳").lt("age", 25);  
List<User> users = userMapper.selectList(wrapper);  
// 下面展示SQL时，仅展示WHERE条件；展示代码时, 仅展示Wrapper构建部分  
// 2. 姓名为黄姓，且年龄大于等于20，小于等于40，且email字段不为空  
// name like '黄%' AND age BETWEEN 20 AND 40 AND email is not null  
wrapper.likeRight("name","黄").between("age", 20, 40).isNotNull("email");  
// 3. 姓名为黄姓，或者年龄大于等于40，按照年龄降序排列，年龄相同则按照id升序排列  
// name like '黄%' OR age >= 40 order by age desc, id asc  
wrapper.likeRight("name","黄").or().ge("age",40).orderByDesc("age").orderByAsc("id");  
// 4.创建日期为2021年3月22日，并且直属上级的名字为李姓  
// date_format(create_time,'%Y-%m-%d') = '2021-03-22' AND manager_id IN (SELECT id FROM user WHERE name like '李%')  
wrapper.apply("date_format(create_time, '%Y-%m-%d') = {0}", "2021-03-22") // 建议采用{index}这种方式动态传参, 可防止SQL注入  
    .inSql("manager_id", "SELECT id FROM user WHERE name like '李%'");  
// 上面的apply, 也可以直接使用下面这种方式做字符串拼接，但当这个日期是一个外部参数时，这种方式有SQL注入的风险  
wrapper.apply("date_format(create_time, '%Y-%m-%d') = '2021-03-22'");  
// 5. 名字为王姓，并且（年龄小于40，或者邮箱不为空）  
// name like '王%' AND (age < 40 OR email is not null)  
wrapper.likeRight("name", "王").and(q -> q.lt("age", 40).or().isNotNull("email"));  
// 6. 名字为王姓，或者（年龄小于40并且年龄大于20并且邮箱不为空）  
// name like '王%' OR (age < 40 AND age > 20 AND email is not null)  
wrapper.likeRight("name", "王").or(  
    q -> q.lt("age",40)  
      .gt("age",20)  
      .isNotNull("email")  
  );  
// 7. (年龄小于40或者邮箱不为空) 并且名字为王姓  
// (age < 40 OR email is not null) AND name like '王%'  
wrapper.nested(q -> q.lt("age", 40).or().isNotNull("email"))  
    .likeRight("name", "王");  
// 8. 年龄为30，31，34，35  
// age IN (30,31,34,35)  
wrapper.in("age", Arrays.asList(30,31,34,35));  
// 或  
wrapper.inSql("age","30,31,34,35");  
wrapper.inSql("age","select age from t_user where age between 30 and 35");
// 9. 年龄为30，31，34，35, 返回满足条件的第一条记录  
// age IN (30,31,34,35) LIMIT 1  
wrapper.in("age", Arrays.asList(30,31,34,35)).last("LIMIT 1");  
// 10. 只选出id, name 列 (QueryWrapper 特有)  
// SELECT id, name FROM user;  
wrapper.select("id", "name");  
// 11. 选出id, name, age, email, 等同于排除 manager_id 和 create_time  
// 当列特别多, 而只需要排除个别列时, 采用上面的方式可能需要写很多个列, 可以采用重载的select方法，指定需要排除的列  
wrapper.select(User.class, info -> {  
   String columnName = info.getColumn();  
   return !"create_time".equals(columnName) && !"manager_id".equals(columnName);  
  });
//将用户名中包含a并且（年龄大于20或者邮箱为null）的用户更新
// lambda中的条件优先执行
wrapper.like("name","a")
                .and(i->i.gt("age",20).or().isNull("email"));

Condition

条件构造器的诸多方法中，均可以指定一个 boolean 类型的参数 condition ，用来决定该条件是否加入最后生成的WHERE语句中，比如

import org.springframework.util.StringUtils
String name = "黄"; // 假设name变量是一个外部传入的参数  
QueryWrapper<User> wrapper = new QueryWrapper<>();  
wrapper.like(StringUtils.hasText(name), "name", name);  
// 仅当 StringUtils.hasText(name) 为 true 时, 会拼接这个like语句到WHERE中  
// 其实就是对下面代码的简化  
if (StringUtils.hasText(name)) {  
 wrapper.like("name", name);  
}

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
//如果name不为null，空字符串，空白传
String name = "";
wrapper.like(StringUtils.isNotBlank(name),"name",name)
//或
if(StringUtils.isNotBlank(name)){
  wrapper.like("name",name)
}

实体对象作为条件

调用构造函数创建一个 Wrapper 对象时，可以传入一个实体对象。后续使用这个 Wrapper 时，会以实体对象中的非空属性，构建WHERE条件（默认构建等值匹配的WHERE条件，这个行为可以通过实体类里各个字段上的 @TableField 注解中的 condition 属性进行改变）

示例如下

@Test  
 public void test3() {  
  User user = new User();  
  user.setName("黄主管");  
  user.setAge(28);  
  QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

上边是根据实体对象中的非空属性，进行了等值匹配查询。

若希望针对某些属性，改变等值匹配的行为，则可以在实体类中用 @TableField 注解进行配置，示例如下

package com.example.mp.po;  
import com.baomidou.mybatisplus.annotation.SqlCondition;  
import com.baomidou.mybatisplus.annotation.TableField;  
import lombok.Data;  
import java.time.LocalDateTime;  
@Data  
public class User {  
 private Long id;  
 @TableField(condition = SqlCondition.LIKE) // 配置该字段使用like进行拼接  
 private String name;  
 private Integer age;  
 private String email;  
 private Long managerId;  
 private LocalDateTime createTime;  
}

运行下面的测试代码

@Test  
 public void test3() {  
  User user = new User();  
  user.setName("黄");  
  QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

以上是对于实体对象中的name字段，采用了like进行拼接

@TableField 中配置的 condition 属性实则是一个字符串， SqlCondition 类中预定义了一些字符串以供选择

package com.baomidou.mybatisplus.annotation;  
public class SqlCondition {  
    //下面的字符串中, %s 是占位符, 第一个 %s 是列名, 第二个 %s 是列的值  
    public static final String EQUAL = "%s=#{%s}";  
    public static final String NOT_EQUAL = "%s&lt;&gt;#{%s}";  
    public static final String LIKE = "%s LIKE CONCAT('%%',#{%s},'%%')";  
    public static final String LIKE_LEFT = "%s LIKE CONCAT('%%',#{%s})";  
    public static final String LIKE_RIGHT = "%s LIKE CONCAT(#{%s},'%%')";  
}

SqlCondition 中提供的配置比较有限，当我们需要 < 或 > 等拼接方式，则需要自己定义。比如

package com.example.mp.po;  
import com.baomidou.mybatisplus.annotation.SqlCondition;  
import com.baomidou.mybatisplus.annotation.TableField;  
import lombok.Data;  
import java.time.LocalDateTime;  
@Data  
public class User {  
 private Long id;  
 @TableField(condition = SqlCondition.LIKE)  
 private String name;  
    @TableField(condition = "%s &gt; #{%s}") // 这里相当于大于, 其中 &gt; 是字符实体  
 private Integer age;  
 private String email;  
 private Long managerId;  
 private LocalDateTime createTime;  
}

测试如下

@Test  
 public void test3() {  
  User user = new User();  
  user.setName("黄");  
        user.setAge(30);  
  QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

可以看出，name属性是用like拼接的，而age属性是用>拼接的

allEq方法

allEq方法传入一个 map ，用来做等值匹配

@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", "黄飞飞");  
  wrapper.allEq(param);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

当allEq方法传入的Map中有value为 null 的元素时，默认会设置为 is null

@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", null);  
  wrapper.allEq(param);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

若想忽略map中value为 null 的元素，可以在调用allEq时，设置参数 boolean null2IsNull 为 false

@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", null);  
  wrapper.allEq(param, false);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

若想要在执行allEq时，过滤掉Map中的某些元素，可以调用allEq的重载方法 allEq(BiPredicate<R, V> filter, Map<R, V> params)

@Test  
 public void test3() {  
  QueryWrapper<User> wrapper = new QueryWrapper<>();  
  Map<String, Object> param = new HashMap<>();  
  param.put("age", 40);  
  param.put("name", "黄飞飞");  
  wrapper.allEq((k,v) -> !"name".equals(k), param); // 过滤掉map中key为name的元素  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

lambda条件构造器

lambda条件构造器，支持lambda表达式，可以不必像普通条件构造器一样，以字符串形式指定列名，它可以直接以实体类的方法引用来指定列。示例如下

@Test  
 public void testLambda() {  
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();  
  wrapper.like(User::getName, "黄").lt(User::getAge, 30);  
  List<User> users = userMapper.selectList(wrapper);  
  users.forEach(System.out::println);  
 }

像普通的条件构造器，列名是用字符串的形式指定，无法在编译期进行列名合法性的检查，这就不如lambda条件构造器来的优雅。

另外，还有个链式lambda条件构造器，使用示例如下

@Test  
 public void testLambda() {  
  LambdaQueryChainWrapper<User> chainWrapper = new LambdaQueryChainWrapper<>(userMapper);  
  List<User> users = chainWrapper.like(User::getName, "黄").gt(User::getAge, 30).list();  
  users.forEach(System.out::println);  
 }

MyBatis-Plus使用详解（上）

注解

CRUD接口

条件构造器

lambda条件构造器

热门文章

最新文章

相关课程

相关电子书