Bootstrap

Wrapper 丨 Mybatis Plus Wrapper操作手册

条件构造器

MyBatis-Plus 提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的 SQL 语句，从而提高开发效率并减少 SQL 注入的风险。

在 MyBatis-Plus 中，Wrapper 类是构建查询和更新条件的核心工具。以下是主要的 Wrapper 类及其功能：

  • AbstractWrapper：这是一个抽象基类，提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑，包括字段（column）、值（value）、操作符（condition）等。所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。

  • QueryWrapper：专门用于构造查询条件，支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件，并且可以组合使用 and 和 or 逻辑。

  • UpdateWrapper：用于构造更新条件，可以在更新数据时指定条件。与 QueryWrapper 类似，它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下，直接设置更新字段和条件。

  • LambdaQueryWrapper：这是一个基于 Lambda 表达式的查询条件构造器，它通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。

  • LambdaUpdateWrapper：类似于 LambdaQueryWrapper，LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件，同样避免了硬编码字段名的问题。

功能详解

MyBatis-Plus 的 Wrapper 类是构建复杂查询和更新条件的关键工具。它允许开发者以链式调用的方式构造 SQL 的 WHERE 子句，提供了极大的灵活性和便利性。

以下是对 Wrapper 功能的提示和注意事项。

温馨提示

条件判断：Wrapper 方法通常接受一个 boolean 类型的参数，用于决定是否将该条件加入到最终的 SQL 中。例如：

 

queryWrapper.like(StringUtils.isNotBlank(name), Entity::getName, name)

.eq(age != null && age >= 0, Entity::getAge, age);
 

 

默认行为：如果某个方法没有显式提供 boolean 类型的参数，则默认为 true，即条件总是会被加入到 SQL 中。
 

泛型参数：Wrapper 类是泛型类，其中 Param 通常指的是 Wrapper 的子类实例，如 QueryWrapper、UpdateWrapper 等。
 

字段引用：在 LambdaWrapper 中，R 代表的是一个函数，用于引用实体类的属性，例如 Entity::getId。而在普通 Wrapper 中，R 代表的是数据库字段名。
 

字段名注意事项：当 R 具体类型为 String 时，表示的是数据库字段名，而不是实体类数据字段名。如果字段名是数据库关键字，需要使用转义符包裹。
 

集合参数：如果方法的参数是 Map 或 List，当它们为空时，对应的 SQL 条件不会被加入到最终的 SQL 中。
 

学习资源：对于不熟悉的函数式编程概念，可以参考学习资源进行学习。
 

注意事项
 

RPC 调用中的 Wrapper：不支持也不赞成在 RPC 调用中传输 Wrapper 对象。Wrapper 对象通常包含大量信息，不适合作为传输对象。正确的做法是定义一个 DTO（数据传输对象）进行传输，然后在被调用方根据 DTO 执行相应的操作。
 

维护性：避免在 Controller 层使用 Map 接收值，这种做法虽然开发时方便，但会给后续的维护带来困难。
 

问题反馈：不接受任何关于 RPC 传输 Wrapper 报错相关的 issue 或 pr。
 

安全性： QueryWrapper UpdateWrapper 字段部分，如有允许 前端传入 SQL 片段 这可能会导致 SQL 注入风险 需要校验，更多查看 预防安全漏洞。
 

Wrapper 类说明
 

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

allEq
 

allEq 方法是 MyBatis-Plus 中用于构建查询条件的方法之一，它允许我们通过一个 Map 来设置多个字段的相等条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 


// 设置所有字段的相等条件，如果字段值为null，则根据null2IsNull参数决定是否设置为IS NULL

allEq(Map<String, Object> params)

allEq(Map<String, Object> params, boolean null2IsNull)

allEq(boolean condition, Map<String, Object> params, boolean null2IsNull)

// 设置所有字段的相等条件，通过filter过滤器决定哪些字段应该被包含，如果字段值为null，则根据null2IsNull参数决定是否设置为IS NULL

allEq(BiPredicate<String, Object> filter, Map<String, Object> params)

allEq(BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)

allEq(boolean condition, BiPredicate<String, Object> filter, Map<String, Object> params, boolean null2IsNull)
 

参数说明
 

 
 
  • params：一个 Map，其中 key 是数据库字段名，value 是对应的字段值。
  • null2IsNull：如果设置为 true，当 Map 中的 value 为 null 时，会调用 isNull 方法；如果设置为 false，则会忽略 value 为 null 的键值对。
  • filter：一个 BiPredicate，用于过滤哪些字段应该被包含在查询条件中。
  • condition：一个布尔值，用于控制是否应用这些条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.allEq(Map.of("id", 1, "name", "老王", "age", null));
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.allEq(Map.of("id", 1, "name", "老王", "age", null));
 

带过滤器的普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.allEq((field, value) -> field.contains("a"), Map.of("id", 1, "name", "老王", "age", null));
 

带过滤器的 Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.allEq((field, value) -> field.contains("a"), Map.of("id", 1, "name", "老王", "age", null));
 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id = 1 AND name = '老王' AND age IS NULL

-- 带过滤器的普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name = '老王' AND age IS NULL
 

 

eq
 

eq 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的相等条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的相等条件

eq(R column, Object val)

// 根据条件设置指定字段的相等条件

eq(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个相等条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.eq("name", "老王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.eq(User::getName, "老王");
 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name = '老王'
 

 

ne
 

ne 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的不相等条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的不相等条件

ne(R column, Object val)

// 根据条件设置指定字段的不相等条件

ne(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个不相等条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.ne("name", "老王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.ne(User::getName, "老王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name <> '老王'
 

gt
 

gt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的大于条件

gt(R column, Object val)

// 根据条件设置指定字段的大于条件

gt(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个大于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.gt("age", 18);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.gt(User::getAge, 18);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age > 18
 

注意事项
 

  • gt 方法适用于数值型字段，对于字符串等非数值型字段，使用 gt 可能会导致不期望的结果或错误。
  • 在使用 gt 方法时，确保 val 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加大于条件，可以使用带有 condition 参数的重载方法。
 

ge
 

ge 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的大于等于条件。  
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的大于等于条件

ge(R column, Object val)

// 根据条件设置指定字段的大于等于条件

ge(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个大于等于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.ge("age", 18);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.ge(User::getAge, 18);
 

生成的 SQL
 


-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age >= 18
 

 
 
注意事项
 
 
  • ge 方法适用于数值型字段，对于字符串等非数值型字段，使用 ge 可能会导致不期望的结果或错误。
  • 在使用 ge 方法时，确保 val 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加大于等于条件，可以使用带有 condition 参数的重载方法。
 

 

lt
 

lt 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的小于条件

lt(R column, Object val)

// 根据条件设置指定字段的小于条件

lt(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个小于是条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.lt("age", 18);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.lt(User::getAge, 18);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age < 18
 

注意事项
 

 
 
  • lt 方法适用于数值型字段，对于字符串等非数值型字段，使用 lt 可能会导致不期望的结果或错误。
  • 在使用 lt 方法时，确保 val 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加小于条件，可以使用带有 condition 参数的重载方法。
 

 

le
 

le 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的小于等于条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的小于等于条件

le(R column, Object val)

// 根据条件设置指定字段的小于等于条件

le(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值。
  • condition：一个布尔值，用于控制是否应用这个小于是条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.le("age", 18);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.le(User::getAge, 18);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age <= 18
 

注意事项
 

 
 
  • le 方法适用于数值型字段，对于字符串等非数值型字段，使用 le 可能会导致不期望的结果或错误。
  • 在使用 le 方法时，确保 val 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加小于等于条件，可以使用带有 condition 参数的重载方法。
 

 

between
 

between 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 BETWEEN 条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 BETWEEN 条件

between(R column, Object val1, Object val2)

// 根据条件设置指定字段的 BETWEEN 条件

between(boolean condition, R column, Object val1, Object val2)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val1：与字段名对应的第一个值，表示 BETWEEN 条件的起始值。
  • val2：与字段名对应的第二个值，表示 BETWEEN 条件的结束值。
  • condition：一个布尔值，用于控制是否应用这个 BETWEEN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.between("age", 18, 30);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.between(User::getAge, 18, 30);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age BETWEEN 18 AND 30
 

 
 
注意事项
 
 
  • between 方法适用于数值型字段，对于字符串等非数值型字段，使用 between 可能会导致不期望的结果或错误。
  • 在使用 between 方法时，确保 val1 和 val2 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加 BETWEEN 条件，可以使用带有 condition 参数的重载方法。
 

 

notBetween
 

notBetween 方法是 MyBatis-Plus 中用于构建查询条件的另一个基本方法，它用于设置单个字段的 NOT BETWEEN 条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 NOT BETWEEN 条件

notBetween(R column, Object val1, Object val2)

// 根据条件设置指定字段的 NOT BETWEEN 条件

notBetween(boolean condition, R column, Object val1, Object val2)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val1：与字段名对应的第一个值，表示 NOT BETWEEN 条件的起始值。
  • val2：与字段名对应的第二个值，表示 NOT BETWEEN 条件的结束值。
  • condition：一个布尔值，用于控制是否应用这个 NOT BETWEEN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notBetween("age", 18, 30);
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notBetween(User::getAge, 18, 30);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age NOT BETWEEN 18 AND 30
 

注意事项
 

 
 
  • notBetween 方法同样适用于数值型字段，对于字符串等非数值型字段，使用 notBetween 可能会导致不期望的结果或错误。
  • 在使用 notBetween 方法时，确保 val1 和 val2 参数的类型与字段类型相匹配，以避免类型转换错误。
  • 如果需要根据某些条件动态添加 NOT BETWEEN 条件，可以使用带有 condition 参数的重载方法。
 

 

like
 

like 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的 LIKE 条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 LIKE 条件

like(R column, Object val)

// 根据条件设置指定字段的 LIKE 条件

like(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示 LIKE 条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个 LIKE 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.like("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.like(User::getName, "王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name LIKE '%王%'
 

 
 
注意事项
 
 
  • like 方法适用于字符串类型的字段，用于模糊匹配。
  • 默认情况下，like 方法会在搜索值前后添加 %，实现全模糊匹配。如果需要左模糊或右模糊匹配，可以使用 likeLeft 或 likeRight 方法。
  • 在使用 like 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加 LIKE 条件，可以使用带有 condition 参数的重载方法。
 

 

notLike
 

notLike 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的 NOT LIKE 条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 NOT LIKE 条件

notLike(R column, Object val)

// 根据条件设置指定字段的 NOT LIKE 条件

notLike(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示 NOT LIKE 条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个 NOT LIKE 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notLike("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notLike(User::getName, "王");
 

生成的 SQL
 


-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name NOT LIKE '%王%'
 

 
 
注意事项
 
 
  • notLike 方法适用于字符串类型的字段，用于排除特定的模糊匹配。
  • 默认情况下，notLike 方法会在搜索值前后添加 %，实现全模糊排除。如果需要排除左模糊或排除右模糊匹配，可以使用 notLikeLeft 或 notLikeRight 方法。
  • 在使用 notLike 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加 NOT LIKE 条件，可以使用带有 condition 参数的重载方法。
 

 

likeLeft
 

likeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的左模糊匹配条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的左模糊匹配条件

likeLeft(R column, Object val)

// 根据条件设置指定字段的左模糊匹配条件

likeLeft(boolean condition, R column, Object val)
 

 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示左模糊匹配条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个左模糊匹配条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.likeLeft("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.likeLeft(User::getName, "王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name LIKE '%王'
 

 
 
注意事项
 
 
  • likeLeft 方法适用于字符串类型的字段，用于左模糊匹配，即匹配以指定字符串开头的记录。
  • 默认情况下，likeLeft 方法会在搜索值前添加 %，实现左模糊匹配。如果需要全模糊或右模糊匹配，可以使用 like 或 likeRight 方法。
  • 在使用 likeLeft 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加左模糊匹配条件，可以使用带有 condition 参数的重载方法。
 

 

通过上述优化，likeLeft 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项，使得开发者能够更容易理解和正确使用该方法。
 

likeRight
 

likeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的基本方法之一，它用于设置单个字段的右模糊匹配条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的右模糊匹配条件

likeRight(R column, Object val)

// 根据条件设置指定字段的右模糊匹配条件

likeRight(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示右模糊匹配条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个右模糊匹配条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.likeRight("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.likeRight(User::getName, "王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name LIKE '王%'
 

 
 
注意事项
 
 
  • likeRight 方法适用于字符串类型的字段，用于右模糊匹配，即匹配以指定字符串结尾的记录。
  • 默认情况下，likeRight 方法会在搜索值后添加 %，实现右模糊匹配。如果需要全模糊或左模糊匹配，可以使用 like 或 likeLeft 方法。
  • 在使用 likeRight 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加右模糊匹配条件，可以使用带有 condition 参数的重载方法。
 

 

notLikeLeft
 

notLikeLeft 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非左模糊匹配条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的非左模糊匹配条件

notLikeLeft(R column, Object val)

// 根据条件设置指定字段的非左模糊匹配条件

notLikeLeft(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示非左模糊匹配条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个非左模糊匹配条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notLikeLeft("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notLikeLeft(User::getName, "王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name NOT LIKE '%王'
 

 
 
注意事项
 
 
  • notLikeLeft 方法适用于字符串类型的字段，用于排除以指定字符串开头的记录。
  • 默认情况下，notLikeLeft 方法会在搜索值前添加 %，实现非左模糊匹配。如果需要排除全模糊或右模糊匹配，可以使用 notLike 或 notLikeRight 方法。
  • 在使用 notLikeLeft 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加非左模糊匹配条件，可以使用带有 condition 参数的重载方法。
 

 

notLikeRight
 

notLikeRight 方法是 MyBatis-Plus 中用于构建模糊查询条件的另一个基本方法，它用于设置单个字段的非右模糊匹配条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的非右模糊匹配条件

notLikeRight(R column, Object val)

// 根据条件设置指定字段的非右模糊匹配条件

notLikeRight(boolean condition, R column, Object val)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • val：与字段名对应的值，表示非右模糊匹配条件中的搜索值。
  • condition：一个布尔值，用于控制是否应用这个非右模糊匹配条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notLikeRight("name", "王");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notLikeRight(User::getName, "王");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name NOT LIKE '王%'
 

 
 
注意事项
 
 
  • notLikeRight 方法适用于字符串类型的字段，用于排除以指定字符串结尾的记录。
  • 默认情况下，notLikeRight 方法会在搜索值后添加 %，实现非右模糊匹配。如果需要排除全模糊或左模糊匹配，可以使用 notLike 或 notLikeLeft 方法。
  • 在使用 notLikeRight 方法时，确保 val 参数的类型是字符串，以避免类型转换错误。
  • 如果需要根据某些条件动态添加非右模糊匹配条件，可以使用带有 condition 参数的重载方法。
 

 

通过上述优化，notLikeRight 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项，使得开发者能够更容易理解和正确使用该方法。
 

isNull
 

isNull 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IS NULL 条件。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 IS NULL 条件

isNull(R column)

// 根据条件设置指定字段的 IS NULL 条件

isNull(boolean condition, R column)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • condition：一个布尔值，用于控制是否应用这个 IS NULL 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.isNull("name");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.isNull(User::getName);
 

生成的 SQL
 


-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE name IS NULL
 

 
 
注意事项
 
 
  • isNull 方法适用于所有类型的字段，用于查询字段值为 NULL 的记录。
  • 在使用 isNull 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加 IS NULL 条件，可以使用带有 condition 参数的重载方法。
 

 

in
 

in 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 IN 条件，即字段的值在给定的集合中。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 IN 条件，使用集合、

in(R column, Collection<?> value)

in(boolean condition, R column, Collection<?> value)

// 设置指定字段的 IN 条件，使用可变参数

in(R column, Object... values)

in(boolean condition, R column, Object... values)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • value：一个集合，包含 IN 条件中字段可能的值。
  • values：一个可变参数列表，包含 IN 条件中字段可能的值。
  • condition：一个布尔值，用于控制是否应用这个 IN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.in("age", Arrays.asList(1, 2, 3));
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.in(User::getAge, Arrays.asList(1, 2, 3));
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age IN (1, 2, 3)
 

 
 
注意事项
 
 
  • in 方法适用于所有类型的字段，用于查询字段值在给定集合中的记录。
  • 在使用 in 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加 IN 条件，可以使用带有 condition 参数的重载方法。
 

 

notIn
 

notIn 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于设置单个字段的 NOT IN 条件，即字段的值不在给定的集合中。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 NOT IN 条件，使用集合

notIn(R column, Collection<?> value)

notIn(boolean condition, R column, Collection<?> value)

// 设置指定字段的 NOT IN 条件，使用可变参数

notIn(R column, Object... values)

notIn(boolean condition, R column, Object... values)
 

 
 
参数说明
 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • value：一个集合，包含 NOT IN 条件中字段可能的值。
  • values：一个可变参数列表，包含 NOT IN 条件中字段可能的值。
  • condition：一个布尔值，用于控制是否应 
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notIn(User::getAge, Arrays.asList(1, 2, 3));
     用这个 NOT IN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notIn("age", Arrays.asList(1, 2, 3));
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notIn(User::getAge, Arrays.asList(1, 2, 3));
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age NOT IN (1, 2, 3)
 

 
 
注意事项
 
 
  • notIn 方法适用于所有类型的字段，用于查询字段值不在给定集合中的记录。
  • 在使用 notIn 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加 NOT IN 条件，可以使用带有 condition 参数的重载方法。
 

 

inSql
 

inSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 IN 条件，但与 in 方法不同的是，inSql 允许你直接使用 SQL 语句来生成 IN 子句中的值集合。
 

 
 
使用范围
 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 IN 条件，使用 SQL 语句

inSql(R column, String sqlValue)

inSql(boolean condition, R column, String sqlValue)
 

 
 
参数说明
 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • sqlValue：一个字符串，包含用于生成 IN 子句中值集合的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个 IN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.inSql("age", "1,2,3,4,5,6");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.inSql(User::getAge, "1,2,3,4,5,6");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)
 

使用子查询的示例：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.inSql("id", "select id from other_table where id < 3");
 

生成的 SQL
 

SELECT * FROM user WHERE id IN (select id from other_table where id < 3)
 

 
 
注意事项
 
 
  • inSql 方法允许你使用 SQL 语句来生成 IN 子句中的值集合，这为复杂的查询条件提供了灵活性。
  • 在使用 inSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • sqlValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加 IN 条件，可以使用带有 condition 参数的重载方法。
 

 

notInSql
 

notInSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置单个字段的 NOT IN 条件，但与 notIn 方法不同的是，notInSql 允许你直接使用 SQL 语句来生成 NOT IN 子句中的值集合。
 

使用范围
 

 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置指定字段的 NOT IN 条件，使用 SQL 语句

notInSql(R column, String sqlValue)

notInSql(boolean condition, R column, String sqlValue)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • sqlValue：一个字符串，包含用于生成 NOT IN 子句中值集合的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个 NOT IN 条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notInSql("age", "1,2,3,4,5,6");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.notInSql(User::getAge, "1,2,3,4,5,6");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)
 

使用子查询的示例
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.notInSql("id", "select id from other_table where id < 3");


 

生成的 SQL
 

SELECT * FROM user WHERE id NOT IN (select id from other_table where id < 3)
 

 
 
注意事项
 
 
  • notInSql 方法允许你使用 SQL 语句来生成 NOT IN 子句中的值集合，这为复杂的查询条件提供了灵活性。
  • 在使用 notInSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • sqlValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加 NOT IN 条件，可以使用带有 condition 参数的重载方法。
 

 

eqSql Since 3.5.6
 

eqSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段等于（EQ）某个 SQL 语句的结果。这个方法特别适用于需要将字段值与子查询结果进行比较的场景。
 

方法签名
 

// 设置指定字段等于 SQL 语句的结果

eqSql(R column, String inValue)

// 在条件满足时设置指定字段等于 SQL 语句的结果

eqSql(boolean condition, R column, String inValue)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • inValue：一个字符串，包含用于生成等于条件的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个等于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.eqSql("id", "select MAX(id) from table");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.eqSql(User::getId, "select MAX(id) from table");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id = (select MAX(id) from table)
 

 
 
注意事项
 
 
  • eqSql 方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。
  • 在使用 eqSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • inValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加等于条件，可以使用带有 condition 参数的重载方法。
 

 

gtSql Since 3.4.3.2
 

gtSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于（GT）某个 SQL 语句的结果。
 

方法签名
 

// 设置指定字段大于 SQL 语句的结果

gtSql(R column, String inValue)

// 在条件满足时设置指定字段大于 SQL 语句的结果

gtSql(boolean condition, R column, String inValue)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • inValue：一个字符串，包含用于生成大于条件的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个大于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.gtSql("id", "select id from table where name = 'xx'");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.gtSql(User::getId, "select id from table where name = 'xx'");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id > (select id from table where name = 'xx')
 

 
 
注意事项
 
 
  • gtSql 方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。
  • 在使用 gtSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • inValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加大于条件，可以使用带有 condition 参数的重载方法。
 

 

geSql Since 3.4.3.2
 

geSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段大于等于（GE）某个 SQL 语句的结果。
 

方法签名
 

// 设置指定字段大于等于 SQL 语句的结果

geSql(R column, String inValue)

// 在条件满足时设置指定字段大于等于 SQL 语句的结果

geSql(boolean condition, R column, String inValue)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • inValue：一个字符串，包含用于生成大于等于条件的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个大于等于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.geSql("id", "select id from table where name = 'xx'");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.geSql(User::getId, "select id from table where name = 'xx'");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id >= (select id from table where name = 'xx')
 

 
 
注意事项
 
 
  • geSql 方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。
  • 在使用 geSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • inValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加大于等于条件，可以使用带有 condition 参数的重载方法。
 

 

ltSql Since 3.4.3.2
 

ltSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段小于（LT）某个 SQL 语句的结果。
 

方法签名
 

// 设置指定字段小于 SQL 语句的结果

ltSql(R column, String inValue)

// 在条件满足时设置指定字段小于 SQL 语句的结果

ltSql(boolean condition, R column, String inValue)
 

参数说明
 

 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • inValue：一个字符串，包含用于生成小于条件的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个小于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.ltSql("id", "select id from table where name = 'xx'");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.ltSql(User::getId, "select id from table where name = 'xx'");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id < (select id from table where name = 'xx')
 

 
 
注意事项
 
 
  • ltSql 方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。
  • 在使用 ltSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • inValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态入并直接引用。
  • 如果需要根据某些条件动态添加小于条件，可以使用带有 condition 参数的重载方法。
 

 

leSql Since 3.4.3.2
 

leSql 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，允许你设置一个字段小于等于（LE）某个 SQL 语句的结果。
 

方法签名
 

// 设置指定字段小于等于 SQL 语句的结果

leSql(R column, String inValue)

// 在条件满足时设置指定字段小于等于 SQL 语句的结果

leSql(boolean condition, R column, String inValue)
 

 
 
参数说明
 
 
  • column：数据库字段名或使用 Lambda 表达式的字段名。
  • inValue：一个字符串，包含用于生成小于等于条件的 SQL 语句。
  • condition：一个布尔值，用于控制是否应用这个小于等于条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.leSql("id", "select id from table where name = 'xx'");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.leSql(User::getId, "select id from table where name = 'xx'");
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user WHERE id <= (select id from table where name = 'xx')
 

 
 
注意事项
 
 
  • leSql 方法允许你将字段值与 SQL 语句的结果进行比较，这为复杂的查询条件提供了灵活性。
  • 在使用 leSql 方法时，确保 column 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • inValue 参数应该是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • 如果需要根据某些条件动态添加小于等于条件，可以使用带有 condition 参数的重载方法。
 

 

groupBy
 

groupBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的分组条件。通过指定一个或多个字段，groupBy 方法可以生成 SQL 语句中的 GROUP BY 子句。
 

 
 
使用范围
 
 
  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

 

方法签名
 

// 设置分组条件，使用字段名

groupBy(R... columns)

groupBy(boolean condition, R... columns)
 

 
 
参数说明
 
 
  • columns：一个可变参数列表，包含用于分组的字段名。
  • condition：一个布尔值，用于控制是否应用这个分组条件。
 

 

示例
 

普通 Wrapper (QueryWrapper)：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.groupBy("id", "name");
 

Lambda Wrapper (LambdaQueryWrapper)：
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();

lambdaQueryWrapper.groupBy(User::getId, User::getName);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

SELECT * FROM user GROUP BY id, name
 

 
 
注意事项
 
 
  • groupBy 方法适用于需要对查询结果进行分组的场景。
  • 在使用 groupBy 方法时，确保 columns 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加分组条件，可以使用带有 condition 参数的重载方法。
 

 

orderByAsc
 

orderByAsc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的升序排序条件。通过指定一个或多个字段，orderByAsc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定升序排序。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置升序排序条件，使用字段名
 

orderByAsc(R... columns)
 

orderByAsc(boolean condition, R... columns)
 

 

参数说明
 

  • columns：一个可变参数列表，包含用于排序的字段名。
  • condition：一个布尔值，用于控制是否应用这个排序条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.orderByAsc("id", "name");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.orderByAsc(User::getId, User::getName);
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user ORDER BY id ASC, name ASC
 

 

注意事项
 

  • orderByAsc 方法适用于需要对查询结果进行升序排序的场景。
  • 在使用 orderByAsc 方法时，确保 columns 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加排序条件，可以使用带有 condition 参数的重载方法。
 

orderByDesc
 

orderByDesc 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的降序排序条件。通过指定一个或多个字段，orderByDesc 方法可以生成 SQL 语句中的 ORDER BY 子句，并指定降序排序。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置降序排序条件，使用字段名
 

orderByDesc(R... columns)
 

orderByDesc(boolean condition, R... columns)
 

 

参数说明
 

  • columns：一个可变参数列表，包含用于排序的字段名。
  • condition：一个布尔值，用于控制是否应用这个排序条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.orderByDesc("id", "name");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.orderByDesc(User::getId, User::getName);
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user ORDER BY id DESC, name DESC
 

 

注意事项
 

  • orderByDesc 方法适用于需要对查询结果进行降序排序的场景。
  • 在使用 orderByDesc 方法时，确保 columns 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加排序条件，可以使用带有 condition 参数的重载方法。
 

orderBy
 

orderBy 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询结果的排序条件。通过指定一个或多个字段以及排序方向（升序或降序），orderBy 方法可以生成 SQL 语句中的 ORDER BY 子句。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置排序条件，使用字段名和排序方向
 

orderBy(boolean condition, boolean isAsc, R... columns)
 

 

参数说明
 

  • condition：一个布尔值，用于控制是否应用这个排序条件。
  • isAsc：一个布尔值，表示排序方向。true 表示升序（ASC），false 表示降序（DESC）。
  • columns：一个可变参数列表，包含用于排序的字段名。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.orderBy(true, true, "id", "name");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.orderBy(true, true, User::getId, User::getName);
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user ORDER BY id ASC, name ASC
 

 

注意事项
 

  • orderBy 方法提供了更灵活的排序设置，允许开发者指定排序方向。
  • 在使用 orderBy 方法时，确保 columns 参数正确指向了数据库中的字段名或使用 Lambda 表达式的字段名。
  • 如果需要根据某些条件动态添加排序条件，可以使用带有 condition 参数的重载方法。
  • 排序可以应用于查询结果的展示，也可以用于优化查询性能，例如通过排序来减少需要扫描的数据量。
 

having
 

having 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置 HAVING 子句，通常与 GROUP BY 一起使用，用于对分组后的数据进行条件筛选。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置 HAVING 子句，使用 SQL 语句和参数
 

having(String sqlHaving, Object... params)
 

having(boolean condition, String sqlHaving, Object... params)
 

 

参数说明
 

  • sqlHaving：一个字符串，包含用于生成 HAVING 子句的 SQL 语句。
  • params：一个可变参数列表，包含 SQL 语句中占位符的替换值。
  • condition：一个布尔值，用于控制是否应用这个 HAVING 条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.groupBy("age").having("sum(age) > 10");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.groupBy(User::getAge).having("sum(age) > {0}", 10);
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user GROUP BY age HAVING sum(age) > 10
 

 

注意事项
 

  • having 方法通常与 groupBy 方法一起使用，用于对分组后的数据进行进一步的筛选。
  • 在使用 having 方法时，确保 sqlHaving 参数是一个有效的 SQL 语句，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • params 参数用于替换 sqlHaving 中的占位符，确保提供的参数类型和数量与占位符匹配。
  • 如果需要根据某些条件动态添加 HAVING 条件，可以使用带有 condition 参数的重载方法。
 

func
 

func 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它提供了一种在链式调用中根据条件执行不同查询操作的机制。通过传入一个 Consumer 函数式接口，func 方法允许你在不中断链式调用的情况下，根据条件执行不同的查询构建逻辑。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 根据条件执行不同的查询构建逻辑
 

func(Consumer<Children> consumer)
 

func(boolean condition, Consumer<Children> consumer)
 

 

参数说明
 

  • consumer：一个 Consumer 函数式接口，它接受一个 Children 类型的参数，并可以调用 Children 对象上的方法来构建查询条件。
  • condition：一个布尔值，用于控制是否应用这个 Consumer 逻辑。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.func(i -> {
 

if (true) {
 

i.eq("id", 1);
 

} else {
 

i.ne("id", 1);
 

}
 

});
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.func(i -> {
 

if (true) {
 

i.eq(User::getId, 1);
 

} else {
 

i.ne(User::getId, 1);
 

}
 

});
 

 

生成的 SQL
 

 

-- 根据条件生成的 SQL 会有所不同
 

-- 如果条件为 true，则生成的 SQL 为：
 

SELECT * FROM user WHERE id = 1
 

-- 如果条件为 false，则生成的 SQL 为：
 

SELECT * FROM user WHERE id != 1
 

 

注意事项
 

  • func 方法提供了一种灵活的方式来根据条件动态构建查询条件，而不需要中断链式调用。
  • 在使用 func 方法时，确保 Consumer 函数式接口中的逻辑正确构建了所需的查询条件。
  • condition 参数用于控制是否应用 Consumer 逻辑，这允许你根据某些条件动态添加查询条件。
  • 由于 func 方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

or
 

or 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 OR 逻辑。通过调用 or 方法，可以改变后续查询条件的连接方式，从默认的 AND 连接变为 OR 连接。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 改变后续查询条件的连接方式为 OR
 

or()
 

or(boolean condition)
 

// 添加 OR 嵌套条件
 

or(Consumer<Param> consumer)
 

or(boolean condition, Consumer<Param> consumer)
 

 

参数说明
 

  • condition：一个布尔值，用于控制是否应用这个 OR 逻辑。
  • consumer：一个 Consumer 函数式接口，它接受一个 Param 类型的参数，并可以调用 Param 对象上的方法来构建 OR 嵌套条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.eq("id", 1).or().eq("name", "老王");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.eq(User::getId, 1).or().eq(User::getName, "老王");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE id = 1 OR name = '老王'
 

 

OR 嵌套示例：
 

 

// 普通 Wrapper
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.or(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
 

.and(j -> j.eq("name", "杜甫").eq("status", "alive")));
 

// Lambda Wrapper
 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.or(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
 

.and(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE (name = '李白' AND status = 'alive') OR (name = '杜甫' AND status = 'alive')
 

 

注意事项
 

  • 主动调用 or 方法表示紧接着下一个查询条件方法不是用 and 连接，而是用 or 连接。
  • 如果不调用 or 方法，则默认使用 and 连接查询条件。
  • or 方法可以嵌套使用，通过传入 Consumer 函数式接口来构建复杂的 OR 嵌套条件。
  • 在使用 or 方法时，确保 condition 参数正确控制了 OR 逻辑的应用。
  • or 方法的嵌套使用可以构建复杂的查询逻辑，但需要注意代码的可读性和维护性。
 

and
 

and 方法是 MyBatis-Plus 中用于构建查询条件的基本方法之一，它用于在查询条件中添加 AND 逻辑。通过调用 and 方法，可以创建 AND 嵌套条件，即在一个 AND 逻辑块中包含多个查询条件。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 添加 AND 嵌套条件
 

and(Consumer<Param> consumer)
 

and(boolean condition, Consumer<Param> consumer)
 

 

参数说明
 

  • consumer：一个 Consumer 函数式接口，它接受一个 Param 类型的参数，并可以调用 Param 对象上的方法来构建 AND 嵌套条件。
  • condition：一个布尔值，用于控制是否应用这个 AND 嵌套逻辑。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.and(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
 

.and(j -> j.eq("name", "杜甫").eq("status", "alive")));
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.and(i -> i.and(j -> j.eq(User::getName, "李白").eq(User::getStatus, "alive"))
 

.and(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE ((name = '李白' AND status = 'alive') AND (name = '杜甫' AND status = 'alive'))
 

 

注意事项
 

  • and 方法的嵌套使用可以构建复杂的查询逻辑，其中 AND 条件可以包含多个查询条件。
  • 在使用 and 方法的嵌套功能时，确保 Consumer 函数式接口中的逻辑正确构建了所需的查询条件。
  • condition 参数用于控制是否应用 Consumer 逻辑，这允许你根据某些条件动态添加查询条件。
  • 由于 and 方法的嵌套使用可以执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

nested
 

nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。通过调用 nested 方法，可以在查询条件中添加一个嵌套的子句，该子句可以包含多个查询条件，并且可以被外部查询条件通过 AND 或 OR 连接。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 添加一个独立的查询条件块
 

nested(Consumer<Param> consumer)
 

nested(boolean condition, Consumer<Param> consumer)
 

 

参数说明
 

  • consumer：一个 Consumer 函数式接口，它接受一个 Param 类型的参数，并可以调用 Param 对象上的方法来构建嵌套的查询条件。
  • condition：一个布尔值，用于控制是否应用这个嵌套逻辑。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.nested(i -> i.eq("name", "李白").ne("status", "活着"));
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.nested(i -> i.eq(User::getName, "李白").ne(User::getStatus, "活着"));
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE (name = '李白' AND status <> '活着')
 

 

注意事项
 

  • nested 方法创建的查询条件块是一个独立的子句，可以被外部查询条件通过 AND 或 OR 连接。
  • 在使用 nested 方法时，确保 Consumer 函数式接口中的逻辑正确构建了所需的查询条件。
  • condition 参数用于控制是否应用 Consumer 逻辑，这允许你根据某些条件动态添加查询条件。
  • 由于 nested 方法可以执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

apply
 

apply 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接拼接 SQL 片段到查询条件中。这个方法特别适用于需要使用数据库函数或其他复杂 SQL 构造的场景。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 拼接 SQL 片段
 

apply(String applySql, Object... params)
 

apply(boolean condition, String applySql, Object... params)
 

 

参数说明
 

  • applySql：一个字符串，包含要拼接的 SQL 片段。
  • params：一个可变参数列表，包含 SQL 片段中占位符的替换值。
  • condition：一个布尔值，用于控制是否应用这个 SQL 片段。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.apply("id = 1");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'");
 

 

使用参数占位符的示例：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = {0}", "2008-08-08");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 生成的 SQL
 

SELECT * FROM user WHERE id = 1
 

-- Lambda Wrapper 生成的 SQL
 

SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
 

-- 使用参数占位符生成的 SQL
 

SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
 

 

注意事项
 

  • apply 方法可用于拼接包含数据库函数的 SQL 片段。
  • 动态入参的 params 对应 applySql 内部的 {index} 部分，这样是不会有 SQL 注入风险的。如果直接将参数拼接到 SQL 中，则会有 SQL 注入风险，故应避免 SQL 由前端动态参数传入并直接引用。
  • 在使用 apply 方法时，确保 applySql 参数是一个有效的 SQL 片段，并且 params 参数正确地替换了占位符。
  • condition 参数用于控制是否应用这个 SQL 片段，这允许你根据某些条件动态添加查询条件。
 

last
 

last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。这个方法应该谨慎使用，因为它可能会绕过 MyBatis-Plus 的查询优化。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 在查询的最后添加一个 SQL 片段
 

last(String lastSql)
 

last(boolean condition, String lastSql)
 

 

参数说明
 

  • lastSql：一个字符串，包含要添加到查询最后的 SQL 片段。
  • condition：一个布尔值，用于控制是否应用这个 SQL 片段。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.last("limit 1");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.last("limit 1");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user LIMIT 1
 

 

注意事项
 

  • last 方法只能调用一次，多次调用将以最后一次为准。
  • 使用 last 方法会绕过 MyBatis-Plus 的查询优化规则，可能会导致查询效率降低。
  • 因为 lastSql 参数直接拼接到 SQL 中，所以必须确保输入的 SQL 片段是安全的，即保障 lastSql 应该是后端自行控制，而不是动态参数由前端传入。
  • 在使用 last 方法时，确保 lastSql 参数是一个安全的 SQL 片段，并且 condition 参数正确地控制了 SQL 片段的应用。
 

exists
 

exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。通过调用 exists 方法，可以将一个完整的 SQL 子查询作为 EXISTS 条件添加到主查询中。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 添加 EXISTS 子查询
 

exists(String existsSql)
 

exists(boolean condition, String existsSql)
 

 

参数说明
 

  • existsSql：一个字符串，包含要作为 EXISTS 条件的 SQL 子查询。
  • condition：一个布尔值，用于控制是否应用这个 EXISTS 条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.exists("select id from table where age = 1");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.exists("select id from table where age = 1");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE EXISTS (select id from table where age = 1)
 

 

注意事项
 

  • exists 方法用于添加一个 EXISTS 子查询，这通常用于检查子查询是否返回任何行。
  • 在使用 exists 方法时，确保 existsSql 参数是一个有效的 SQL 子查询，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • condition 参数用于控制是否应用 EXISTS 条件，这允许你根据某些条件动态添加查询条件。
  • 由于 exists 方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

notExists
 

notExists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 NOT EXISTS 子查询。通过调用 notExists 方法，可以将一个完整的 SQL 子查询作为 NOT EXISTS 条件添加到主查询中。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 添加 NOT EXISTS 子查询
 

notExists(String notExistsSql)
 

notExists(boolean condition, String notExistsSql)
 

 

参数说明
 

  • notExistsSql：一个字符串，包含要作为 NOT EXISTS 条件的 SQL 子查询。
  • condition：一个布尔值，用于控制是否应用这个 NOT EXISTS 条件。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.notExists("select id from table where age = 1");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.notExists("select id from table where age = 1");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT * FROM user WHERE NOT EXISTS (select id from table where age = 1)
 

 

注意事项
 

  • notExists 方法用于添加一个 NOT EXISTS 子查询，这通常用于检查子查询是否不返回任何行。
  • 在使用 notExists 方法时，确保 notExistsSql 参数是一个有效的 SQL 子查询，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用。
  • condition 参数用于控制是否应用 NOT EXISTS 条件，这允许你根据某些条件动态添加查询条件。
  • 由于 notExists 方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

select
 

select 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于设置查询的字段。通过调用 select 方法，可以指定在查询结果中包含哪些字段，从而实现字段级别的查询定制。
 

使用范围
 

  • QueryWrapper
  • LambdaQueryWrapper
 

方法签名
 

 

// 设置查询字段
 

select(String... sqlSelect)
 

// 过滤查询字段（主键除外）
 

select(Predicate<TableFieldInfo> predicate)
 

select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)
 

 

参数说明
 

  • sqlSelect：一个字符串数组，包含要查询的字段名。
  • predicate：一个 Predicate 函数式接口，用于过滤查询字段。它接受一个 TableFieldInfo 类型的参数，并返回一个布尔值，表示是否选择该字段。
  • entityClass：实体类的类型，用于获取字段信息。
 

示例
 

普通 Wrapper (QueryWrapper)：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.select("id", "name", "age");
 

 

Lambda Wrapper (LambdaQueryWrapper)：
 

 

LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
 

lambdaQueryWrapper.select("id", "name", "age");
 

 

使用 Predicate 过滤字段的示例：
 

 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 

queryWrapper.select(i -> i.getProperty().startsWith("test"));
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

SELECT id, name, age FROM user
 

-- 使用 Predicate 过滤字段生成的 SQL
 

SELECT testField1, testField2 FROM user
 

 

说明
 

  • select 方法分为两类：第一类直接指定要查询的字段名，第二类通过 Predicate 过滤字段。
  • 第二类方法用于过滤查询字段（主键除外），如果入参不包含 entityClass，则在调用前需要确保 wrapper 内的 entity 属性有值。
  • 这两类方法重复调用时，以最后一次调用为准。
  • 在使用 select 方法时，确保指定的字段名或过滤条件正确，以避免查询结果不符合预期。
 

set
 

set 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它用于设置更新语句中的 SET 字段。通过调用 set 方法，可以指定在更新操作中要修改的字段及其新值。
 

使用范围
 

  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置更新语句中的 SET 字段
 

set(String column, Object val)
 

set(boolean condition, String column, Object val)
 

 

参数说明
 

  • column：一个字符串，表示要更新的字段名。
  • val：一个对象，表示要更新到字段的新值。
  • condition：一个布尔值，用于控制是否应用这个 SET 字段。
 

示例
 

普通 Wrapper (UpdateWrapper)：
 

 

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
 

updateWrapper.set("name", "老李头");
 

 

Lambda Wrapper (LambdaUpdateWrapper)：
 

 

LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
 

lambdaUpdateWrapper.set(User::getName, "老李头");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

UPDATE user SET name = '老李头'
 

 

使用条件控制的示例：
 

 

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
 

updateWrapper.set(true, "name", "");
 

 

生成的 SQL
 

 

-- 使用条件控制的 SQL
 

UPDATE user SET name = ''
 

 

注意事项
 

  • set 方法用于设置更新语句中的 SET 字段，可以指定要更新的字段及其新值。
  • 当 val 参数为空字符串时，数据库字段值将变为空字符串。
  • 当 val 参数为 null 时，数据库字段值将变为 null。
  • condition 参数用于控制是否应用这个 SET 字段，这允许你根据某些条件动态添加更新字段。
  • 在使用 set 方法时，确保 column 参数是一个有效的字段名，并且 val 参数是一个合适的新值。
 

setSql
 

setSql 方法是 MyBatis-Plus 中用于构建更新操作的高级方法之一，它允许你直接设置更新语句中的 SET 部分 SQL。通过调用 setSql 方法，可以将一个自定义的 SQL 片段作为 SET 子句添加到更新语句中。
 

使用范围
 

  • UpdateWrapper
  • LambdaUpdateWrapper
 

方法签名
 

 

// 设置更新语句中的 SET 部分 SQL
 

setSql(String sql)
 

 

参数说明
 

  • sql：一个字符串，包含要作为 SET 子句的 SQL 片段。
 

示例
 

普通 Wrapper (UpdateWrapper)：
 

 

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
 

updateWrapper.setSql("name = '老李头'");
 

 

Lambda Wrapper (LambdaUpdateWrapper)：
 

 

LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
 

lambdaUpdateWrapper.setSql("name = '老李头'");
 

 

生成的 SQL
 

 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
 

UPDATE user SET name = '老李头'
 

 

注意事项
 

  • setSql 方法用于设置更新语句中的 SET 部分 SQL，这通常用于需要使用复杂 SQL 构造的场景。
  • 在使用 setSql 方法时，确保 sql 参数是一个有效的 SQL 片段，它将直接嵌入到生成的 SQL 中，因此需要确保其安全性和正确性，应避免 SQL 由前端动态参数传入并直接引用
  • 由于 setSql 方法允许执行复杂的逻辑，因此在使用时需要特别注意代码的可读性和维护性。
 

setIncrBy Since 3.5.6
 

setIncrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值增加指定的数值。这个方法特别适用于需要对数值字段进行增量操作的场景。
 

使用范围
 

  • LambdaUpdateWrapper
 

方法签名
 

 

// 字段自增指定数值
 

setIncrBy(SFunction<T, ?> column, Number val)
 

// 在条件满足时字段自增指定数值
 

setIncrBy(boolean condition, SFunction<T, ?> column, Number val)
 

 

参数说明
 

  • column：一个 SFunction 对象，表示要自增的字段。
  • val：一个 Number 对象，表示要增加的数值。
  • condition（可选）：一个布尔值，表示是否在满足条件时执行自增操作。
 

示例
 

普通 Wrapper (UpdateWrapper)：
 

 

UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();
 

updateWrapper.setIncrBy(Product::getNum, 1);
 

 

Lambda Wrapper (LambdaUpdateWrapper)：
 

 

LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
 

lambdaUpdateWrapper.setIncrBy(Product::getNum, 1);
 

 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

UPDATE product SET num = num + 1
 

 
 
注意事项
 
 
  • setIncrBy 方法用于对指定字段进行自增操作，这通常用于需要对数值字段进行增量更新的场景。
  • 在使用 setIncrBy 方法时，确保 column 参数是一个有效的字段表达式，val 参数是一个有效的数值。
  • 如果提供了 condition 参数，则只有在条件为 true 时才会执行自增操作。
 

 

setDecrBy Since 3.5.6
 

setDecrBy 方法是 MyBatis-Plus 中用于更新操作的高级方法之一，它允许你指定一个字段，并使其在数据库中的值减少指定的数值。这个方法特别适用于需要对数值字段进行减量操作的场景。
 

使用范围
 

  • LambdaUpdateWrapper
 

方法签名
 

// 字段自减指定数值

setDecrBy(SFunction<T, ?> column, Number val)

// 在条件满足时字段自减指定数值

setDecrBy(boolean condition, SFunction<T, ?> column, Number val)
 

参数说明
 

 
 
  • column：一个 SFunction 对象，表示要自减的字段。
  • val：一个 Number 对象，表示要减少的数值。
  • condition（可选）：一个布尔值，表示是否在满足条件时执行自减操作。
 

 

示例
 

普通 Wrapper (UpdateWrapper)：
 

UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();

updateWrapper.setDecrBy(Product::getNum, 1);
 

Lambda Wrapper (LambdaUpdateWrapper)：
 

LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();

lambdaUpdateWrapper.setDecrBy(Product::getNum, 1);
 

生成的 SQL
 

-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同

UPDATE product SET num = num - 1
 

 
 
注意事项
 
 
  • setDecrBy 方法用于对指定字段进行自减操作，这通常用于需要对数值字段进行减量更新的场景。
  • 在使用 setDecrBy 方法时，确保 column 参数是一个有效的字段表达式，val 参数是一个有效的数值。
  • 如果提供了 condition 参数，则只有在条件为 true 时才会执行自减操作。
 

 

lambda
 

lambda 方法是一个便捷的方法，它允许你从 QueryWrapper 或 UpdateWrapper 对象中获取对应的 LambdaQueryWrapper 或 LambdaUpdateWrapper 对象。这样，你就可以使用 Lambda 表达式来构建查询或更新条件，使得代码更加简洁和类型安全。
 

使用范围
 

  • QueryWrapper
  • UpdateWrapper
 

方法签名
 

// 获取 Lamdba Wrapper

lambda();
 

示例
 

从 QueryWrapper 获取 LambdaQueryWrapper：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();

// 使用 Lambda 表达式构建查询条件

lambdaQueryWrapper.eq(User::getName, "张三");
 

从 UpdateWrapper 获取 LambdaUpdateWrapper：
 

UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();

LambdaUpdateWrapper<User> lambdaUpdateWrapper = updateWrapper.lambda();

// 使用 Lambda 表达式构建更新条件

lambdaUpdateWrapper.set(User::getName, "李四");
 

说明
 

  • lambda 方法返回一个 LambdaWrapper 对象，具体类型取决于调用它的 Wrapper 类型。
  • 在 QueryWrapper 上调用 lambda 方法将返回一个 LambdaQueryWrapper。
  • 在 UpdateWrapper 上调用 lambda 方法将返回一个 LambdaUpdateWrapper。
  • 使用 Lambda 表达式可以避免直接使用字符串来指定字段名，从而减少错误并提高代码的可读性。
 

注意事项
 

  • 在使用 lambda 方法时，确保你已经正确地初始化了 QueryWrapper 或 UpdateWrapper 对象。
  • 一旦获取了 LambdaWrapper 对象，你就可以使用 Lambda 表达式来构建查询或更新条件，这将使得代码更加类型安全和易于维护。
 

使用提示
 

通过使用 MyBatis-Plus 的 Wrapper 条件构造器，开发者可以更加高效地构建复杂的数据库查询条件，同时保持代码的简洁性和安全性。以下是一些注意事项与推荐做法：
 

  • 在使用 Wrapper 时，尽量使用 Lambda 表达式来避免硬编码字段名，这样可以提高代码的可读性和可维护性。
  • Wrapper 支持链式调用，可以组合多个条件，如 and、or 等逻辑操作符。
  • 在更新操作中使用 UpdateWrapper 或 LambdaUpdateWrapper 时，可以省略实体对象，直接在 Wrapper 中设置更新字段。
  • 注意 Wrapper 的线程安全性，通常在每次使用时创建新的 Wrapper 实例。
  • 在使用 MyBatis-Plus 的 Wrapper 时，应避免将前端动态参数直接拼接到 SQL 片段中，以防止 SQL 注入攻击。MyBatis-Plus 提供了安全的参数绑定方式，如使用 eq、apply 等方法，它们会自动处理参数绑定，避免 SQL 注入风险。
 

Wrappers
 

MyBatis-Plus 提供了 Wrappers 类，它是一个静态工厂类，用于快速创建 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 的实例。使用 Wrappers 可以减少代码量，提高开发效率。
 

示例：
 

// 创建 QueryWrapper

QueryWrapper<User> queryWrapper = Wrappers.query();

queryWrapper.eq("name", "张三");

// 创建 LambdaQueryWrapper

LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();

lambdaQueryWrapper.eq(User::getName, "张三");

// 创建 UpdateWrapper

UpdateWrapper<User> updateWrapper = Wrappers.update();

updateWrapper.set("name", "李四");

// 创建 LambdaUpdateWrapper

LambdaUpdateWrapper<User> lambdaUpdateWrapper = Wrappers.lambdaUpdate();

lambdaUpdateWrapper.set(User::getName, "李四");
 

注意事项
 

  • 在使用 QueryWrapper UpdateWrapper 查询 设置 条件字段部分 一定要保证安全，避免 SQL 注入攻击。
  • 任何 前端 传入的 SQL片段 都要 严格过滤 更多查看 数据安全保护 预防安全漏洞
 

线程安全性
 

Wrapper 实例不是线程安全的，因此建议在每次使用时创建新的 Wrapper 实例。这样可以避免多线程环境下的数据竞争和潜在的错误。
 

示例：
 

// 在每个方法或请求中创建新的 Wrapper 实例

public List<User> getUsersByName(String name) {

QueryWrapper<User> queryWrapper = Wrappers.query();

queryWrapper.eq("name", name);

return userMapper.selectList(queryWrapper);

}
 

通过遵循这些最佳实践，开发者可以更加安全、高效地使用 MyBatis-Plus 的 Wrapper 条件构造器，构建出既安全又易于维护的数据库操作代码。
 

使用 Wrapper 自定义 SQL
 

MyBatis-Plus 提供了强大的 Wrapper 条件构造器，允许开发者自定义 SQL 语句，以满足更复杂的数据库查询需求。为了使用这一功能，请确保你的 mybatis-plus 版本不低于 3.0.7。
 

注意事项
 

  • 版本要求：确保你的项目中使用的 mybatis-plus 版本至少为 3.0.7，以支持自定义 SQL 功能。
  • 参数命名：在自定义 SQL 时，传递 Wrapper 对象作为参数时，参数名必须为 ew，或者使用注解 @Param(Constants.WRAPPER) 明确指定参数为 Wrapper 对象。
  • 使用 ${ew.customSqlSegment}：在 SQL 语句中，使用 ${ew.customSqlSegment} 来引用 Wrapper 对象生成的 SQL 片段。
  • 不支持基于 entity 的 where 语句：自定义 SQL 时，Wrapper 对象不会基于实体类自动生成 where 子句，你需要手动编写完整的 SQL 语句。
 

示例
 

以下是一个使用 Wrapper 自定义 SQL 的示例：
 

import com.baomidou.mybatisplus.core.conditions.Wrapper;

import com.baomidou.mybatisplus.core.toolkit.Constants;

import org.apache.ibatis.annotations.Param;

public interface UserMapper extends BaseMapper<User> {

@Select("SELECT * FROM user ${ew.customSqlSegment}")

List<User> selectByCustomSql(@Param(Constants.WRAPPER) Wrapper<User> wrapper);

}
 

在上述示例中，我们定义了一个 selectByCustomSql 方法，它使用了一个自定义的 SQL 语句，并通过 ${ew.customSqlSegment} 引入了 Wrapper 对象生成的 SQL 片段。
 

使用方法
 

要使用自定义 SQL，只需调用上述方法并传入一个 Wrapper 对象：
 

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

queryWrapper.eq("name", "张三");

List<User> userList = userMapper.selectByCustomSql(queryWrapper);
 

在这个例子中，selectByCustomSql 方法将执行一个带有 where 条件的查询，该条件由传入的 queryWrapper 对象生成。
 

通过这种方式，你可以灵活地结合 MyBatis-Plus 的 Wrapper 功能和自定义 SQL，以满足各种复杂的数据库操作需求。
 

Kotlin持久化对象定义最佳实践
 

在Kotlin中定义持久化对象时，我们应当遵循一些最佳实践，以确保代码的清晰性和可维护性。以下是一个使用MyBatis-Plus的示例，展示了如何定义一个持久化对象：
 

@TableName("sys_user")

class User {

@TableId(type = IdType.AUTO)

var id: Int? = null

@TableField("username")

var name: String? = null

var roleId: Int? = null

}
 

注意：上述代码中的@TableId和@TableField注解是为了展示MyBatis-Plus的使用，并非必须。所有成员变量都应定义为可空类型，并赋予初始值null，以便在类似Java中的updateSelective场景中使用。
 

不推荐使用data class或全参数构造方法，因为这可能导致在创建空对象时需要提供不必要的null值。
 

使用注解查询
 

@Select("select * from mysql_data ${ew.customSqlSegment}")

List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);
 

使用XML配置查询
 

List<MysqlData> getAll(Wrapper ew);

<select id="getAll" resultType="MysqlData">

SELECT * FROM mysql_data ${ew.customSqlSegment}

</select>
 

Kotlin中使用Wrapper
 

Kotlin支持QueryWrapper和UpdateWrapper，但不支持LambdaQueryWrapper和LambdaUpdateWrapper。如果需要使用Lambda风格的Wrapper，可以使用KtQueryWrapper和KtUpdateWrapper。
 

参考示例：
 

val queryWrapper = KtQueryWrapper(User()).eq(User::name, "sss").eq(User::roleId, "sss2")

userMapper!!.selectList(queryWrapper)

val updateConditionWrapper = KtUpdateWrapper(User()).eq(User::name, "sss").eq(User::roleId, "sss2")

val updateRecord = User()

updateRecord.name = "newName"

userMapper!!.update(updateRecord, updateConditionWrapper)

val updateRecord = User()

updateRecord.id = 2

updateRecord.name = "haha"

userMapper.updateById(updateRecord)
 

链式调用与Lambda式调用
 

MyBatis-Plus提供了两种风格的链式调用：普通链式调用和Lambda式链式调用。需要注意的是，Lambda式链式调用不支持Kotlin。
 

// 普通链式调用

UpdateChainWrapper<T> update();

// Lambda式链式调用（不支持Kotlin）

LambdaUpdateChainWrapper<T> lambdaUpdate();

// 等价示例：

query().eq("id", value).one();

lambdaQuery().eq(Entity::getId, value).one();

// 等价示例：

update().eq("id", value).remove();

lambdaUpdate().eq(Entity::getId, value).remove();
 

通过遵循这些最佳实践，我们可以确保Kotlin中的持久化对象定义既清晰又易于维护，同时充分利用MyBatis-Plus提供的功能。

                
      


    


    

      




    

      
悦读

      
道可道，非常道；名可名，非常名。
无名，天地之始，有名，万物之母。
故常无欲，以观其妙，常有欲，以观其徼。
此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

    


    
    
    
    
    
    
    
    

    
    




  
    最新收录
  
  

    
    
    
      
《C Primer Plus》第15章复习题与编程练习

    
    
    
      
Dockerfile

    
    
    
      
Android14应用启动流程（源码+Trace）

    
    
    
      
SLAM实习面试题

    
    
    
      
springboot 整合 mybatis-plus（单表增删改查）

    
    
    
      
Vue2数据响应式再次理解

    
    
    
      
Shell编程之条件语句

    
    
    
      
android安卓源码海量项目合集打包-1

    
    
    
      
接口测试用例设计的关键步骤与技巧有哪些？

    
    
    
      
Linux-ubuntu环境配置

    
    

  




    
   
  







  









  












;