MyBatis-plus 是一款 Mybatis 增强工具，用于简化开发，提高效率。下文使用缩写 mp来简化表示 MyBatis-plus，本文主要介绍 mp 搭配 Spring Boot 的使用。

快速入门

1.创建一个Spring Boot项目。

2.导入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.5.5</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.ccode</groupId>
  12.     <artifactId>springboot-mp</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>springboot-mp</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  19.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>mysql</groupId>
  28.             <artifactId>mysql-connector-java</artifactId>
  29.             <scope>runtime</scope>
  30.         </dependency>
  32.         <dependency>
  33.             <groupId>org.projectlombok</groupId>
  34.             <artifactId>lombok</artifactId>
  35.             <optional>true</optional>
  36.         </dependency>
  38.         <dependency>
  39.             <groupId>org.springframework.boot</groupId>
  40.             <artifactId>spring-boot-starter-test</artifactId>
  41.             <scope>test</scope>
  42.         </dependency>
  44.         <dependency>
  45.             <groupId>org.springframework.boot</groupId>
  46.             <artifactId>spring-boot-configuration-processor</artifactId>
  47.         </dependency>
  49.         <dependency>
  50.             <groupId>com.baomidou</groupId>
  51.             <artifactId>mybatis-plus-boot-starter</artifactId>
  52.             <version>3.4.2</version>
  53.         </dependency>
  55.         <dependency>
  56.             <groupId>junit</groupId>
  57.             <artifactId>junit</artifactId>
  58.             <version>4.12</version>
  59.             <scope>test</scope>
  60.         </dependency>
  62.     </dependencies>
  64.     <build>
  65.         <plugins>
  66.             <plugin>
  67.                 <groupId>org.springframework.boot</groupId>
  68.                 <artifactId>spring-boot-maven-plugin</artifactId>
  69.                 <configuration>
  70.                     <excludes>
  71.                         <exclude>
  72.                             <groupId>org.projectlombok</groupId>
  73.                             <artifactId>lombok</artifactId>
  74.                         </exclude>
  75.                     </excludes>
  76.                 </configuration>
  77.             </plugin>
  78.         </plugins>
  79.     </build>
  81. </project>

3.配置数据库

  1. # application.yml 
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://192.168.71.128:3306/test?serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root
  9. mybatis-plus:
  10.   configuration:
  11.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启sql语句打印

4.创建一个实体类

  1. package com.ccode.pojo;
  3. import lombok.Data;
  5. import java.time.LocalDateTime;
  7. /**
  8.  * @auther 14632
  9.  * @date 2021/10/3 18:11
  10.  */
  11. @Data
  12. public class User {
  13.     private Long id;
  14.     private String name;
  15.     private Integer age;
  16.     private String email;
  17.     private Long managerId;
  18.     private LocalDateTime createTime;
  19. }

5.创建一个mapper接口

  1. package com.ccode.mapper;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.ccode.pojo.User;
  6. /**
  7.  * @auther 14632
  8.  * @date 2021/10/3 18:12
  9.  */
  10. public interface UserMapper extends BaseMapper<User> {
  11. }

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

  1. package com.ccode;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. @SpringBootApplication
  8. @MapperScan("com.ccode.mapper")
  9. public class SpringbootMpApplication {
  11.     public static void main(String[] args) {
  12.         SpringApplication.run(SpringbootMpApplication.class, args);
  13.     }
  15. }

7.在数据库中创建表

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

8.编写一个SpringBoot测试类

  1. package com.ccode;
  3. import com.ccode.mapper.UserMapper;
  4. import com.ccode.pojo.User;
  5. import org.junit.Test;
  6. import org.junit.runner.RunWith;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.test.context.junit4.SpringRunner;
  11. import java.util.List;
  13. /**
  14.  * @auther 14632
  15.  * @date 2021/10/3 19:41
  16.  */
  17. @RunWith(SpringRunner.class)
  18. @SpringBootTest
  19. public class SampleTest {
  20.     @Autowired
  21.     private UserMapper userMapper;
  23.     @Test
  24.     public void testSelect(){
  25.         List<User> list = userMapper.selectList(null);
  26.         assertEquals(5, list.size());
  27.         list.forEach(System.out::println);
  28.     }
  30.     private void assertEquals(int i, int size) {
  31.     }
  34. }

运行测试类
图片.png
运行测试类
图片.png

核心功能

注解

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

@TableName

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

@TableId

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

@TableField

  • 排除非表字段

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

  • 字段验证策略 

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

  • 字段填充策略

    1.  通过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 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，获取到指定的列后，再自行进行处理即可

  1.  @Test
  2.     public void test1(){
  3.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  4.         queryWrapper.select("id","name","email").likeRight("name","黄");
  5.         List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
  6.         maps.forEach(System.out::println);
  7.     }

图片.png进行数据统计

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

图片.png

selectObjs

只会返回第一个字段（第一列）的值，其他字段会被舍弃
比如：

  1.  @Test
  2.     public void test3() {
  3.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  4.         wrapper.select("id", "name").like("name", "黄");
  5.         List<Object> objects = userMapper.selectObjs(wrapper);
  6.         objects.forEach(System.out::println);
  7.     }

图片.png
得到的结果，只封装了第一列的id

selectCount

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

  1. @Test
  2.     public void test4() {
  3.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  4.         wrapper.like("name", "黄");
  6.         Integer count = userMapper.selectCount(wrapper);
  7.         System.out.println(count);
  8.     }

图片.png

Service CRUD 接口

另外一套CRUD是Service层的，只需要编写一个接口，继承IService，并创建一个接口实现类，即可食用。（这个接口提供的CRUD方法，和Mapper接口提供的功能大同小异，比较明显的区别在于IService支持了更多的批量化操作，如saveBatch，saveOrUpdateBatch等方法。

1.首先，新建一个接口，继承IService

  1. package com.ccode.service;
  3. import com.baomidou.mybatisplus.extension.service.IService;
  4. import com.ccode.pojo.User;
  6. /**
  7.  * @auther 14632
  8.  * @date 2021/10/3 20:50
  9.  */
  10. public interface UserService extends IService<User> {
  12. }

2.创建这个接口的实现类，并继承ServiceImpl，最后打上@Service注解，注册到Spring容器中，即可使用

  1. package com.ccode.service.impl;
  3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  4. import com.ccode.mapper.UserMapper;
  5. import com.ccode.pojo.User;
  6. import com.ccode.service.UserService;
  8. /**
  9.  * @auther 14632
  10.  * @date 2021/10/3 20:53
  11.  */
  12. @Service
  13. public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
  14. }

3.测试代码

  1. package com.ccode;
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  5. import com.ccode.pojo.User;
  6. import com.ccode.service.UserService;
  7. import org.junit.Test;
  8. import org.junit.runner.RunWith;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.boot.test.context.SpringBootTest;
  11. import org.springframework.test.context.junit4.SpringRunner;
  13. /**
  14.  * @auther 14632
  15.  * @date 2021/10/3 20:55
  16.  */
  17. @SpringBootTest
  18. @RunWith(SpringRunner.class)
  19. public class ServiceTest {
  20.     @Autowired
  21.     private UserService userService;
  23.     @Test
  24.     public void testGetOne() {
  25.         LambdaQueryWrapper<User> wrapper = Wrappers.<User>lambdaQuery();
  26.         wrapper.gt(User::getAge, 28);
  27.         User one = userService.getOne(wrapper, false); // 第二参数指定为false,使得在查到了多行记录时,不抛出异常,而返回第一条记录
  28.         System.out.println(one);
  29.     }
  30. }

图片.png
另，IService也支持链式调用，代码写起来非常简洁，查询示例如下

  1. @Test  
  2.  public void testChain() {  
  3.   List<User> list = userService.lambdaQuery()  
  4.     .gt(User::getAge, 39)  
  5.     .likeRight(User::getName, "王")  
  6.     .list();  
  7.   list.forEach(System.out::println);  
  8.  }

更新示例如下

  1. @Test  
  2.  public void testChain1() {  
  3.   userService.lambdaUpdate()  
  4.     .gt(User::getAge, 39)  
  5.     .likeRight(User::getName, "王")  
  6.     .set(User::getEmail, "w39@baomidou.com")  
  7.     .update();  
  8.  }

图片.png

删除示例如下

  1. @Test  
  2.  public void testChain2() {  
  3.   userService.lambdaUpdate()  
  4.     .like(User::getName, "青蛙")  
  5.     .remove();  
  6.  }

图片.png

条件构造器

mp让我觉得极其方便的一点在于其提供了强大的条件构造器Wrapper，可以非常方便的构造WHERE条件。条件构造器主要涉及到3个类，AbstractWrapper。QueryWrapper，UpdateWrapper，它们的类关系如下
13.png
在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
  • in
  • and：SQL连接符AND
  • or：SQL连接符OR
  • apply：用于拼接SQL，该方法可用于数据库函数，并可以动态传参
  • …….

使用示例

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

Condition

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

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

实体对象作为条件

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

示例如下：

  1. @Test  
  2.  public void test1() {  
  3.   User user = new User();  
  4.   user.setName("黄主管");  
  5.   user.setAge(28);  
  6.   QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  7.   List<User> users = userMapper.selectList(wrapper);  
  8.   users.forEach(System.out::println);  
  9.  }

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

  1. package com.ccode.pojo;
  3. import com.baomidou.mybatisplus.annotation.SqlCondition;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  5. import lombok.Data;
  7. import java.time.LocalDateTime;
  9. /**
  10.  * @auther 14632
  11.  * @date 2021/10/3 18:11
  12.  */
  13. @Data
  14. public class User {
  15.     private Long id;
  16.     @TableField(condition = SqlCondition.LIKE) // 配置该字段使用like进行拼接
  17.     private String name;
  18.     private Integer age;
  19.     private String email;
  20.     private Long managerId;
  21.     private LocalDateTime createTime;
  22. }

运行下面的测试代码

  1. @Test  
  2.  public void test3() {  
  3.   User user = new User();  
  4.   user.setName("黄");  
  5.   QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  6.   List<User> users = userMapper.selectList(wrapper);  
  7.   users.forEach(System.out::println);  
  8.  }

从下图得到的结果来看，对于实体对象中的name字段，采用了like进行拼接
图片.png
@TableField中配置的condition属性实则是一个字符串，SqlCondition类中预定义了一些字符串以供选择

  1. package com.ccode.condition;
  3. /**
  4.  * @auther 14632
  5. * @date 2021/10/3 21:33
  6.  */
  7. public class SqlCondition {
  8.     //下面的字符串中, %s 是占位符, 第一个 %s 是列名, 第二个 %s 是列的值
  9.     public static final String EQUAL = "%s=#{%s}";
  10.     public static final String NOT_EQUAL = "%s&lt;&gt;#{%s}";
  11.     public static final String LIKE = "%s LIKE CONCAT('%%',#{%s},'%%')";
  12.     public static final String LIKE_LEFT = "%s LIKE CONCAT('%%',#{%s})";
  13.     public static final String LIKE_RIGHT = "%s LIKE CONCAT(#{%s},'%%')";
  14. }

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

  1. package com.ccode.pojo;
  3. import com.baomidou.mybatisplus.annotation.SqlCondition;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  5. import lombok.Data;
  7. import java.time.LocalDateTime;
  9. /**
  10.  * @auther 14632
  11.  * @date 2021/10/3 18:11
  12.  */
  13. @Data
  14. public class User {
  15.     private Long id;
  16.     @TableField(condition = SqlCondition.LIKE) // 配置该字段使用like进行拼接
  17.     private String name;
  18.     @TableField(condition = "%s &gt; #{%s}") // 这里相当于大于, 其中 &gt; 是字符实体
  19.     private Integer age;
  20.     private String email;
  21.     private Long managerId;
  22.     private LocalDateTime createTime;
  23. }

测试如下

  1. @Test  
  2.  public void test3() {  
  3.   User user = new User();  
  4.   user.setName("黄");  
  5.         user.setAge(30);  
  6.   QueryWrapper<User> wrapper = new QueryWrapper<>(user);  
  7.   List<User> users = userMapper.selectList(wrapper);  
  8.   users.forEach(System.out::println);  
  9.  }

从下图得到的结果，可以看出，name属性是用like拼接的，而age属性是用>拼接的
图片.png

allEq方法