跳转到内容

条件构造器

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

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

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

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

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

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

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

功能详解

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

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

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 中的 valuenull 时,会调用 isNull 方法;如果设置为 false,则会忽略 valuenull 的键值对。
  • 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

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

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

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

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

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

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 '%王%'

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 '%王%'

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 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项,使得开发者能够更容易理解和正确使用该方法。

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 '王%'

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 '%王'

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 方法的文档更加清晰地展示了其用法、参数说明、示例以及注意事项,使得开发者能够更容易理解和正确使用该方法。

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

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)

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:一个布尔值,用于控制是否应用这个 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)

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)

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)

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)

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

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

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

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

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

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

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

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

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

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

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

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

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 <> '活着')

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

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)

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)

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

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 = ''

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 = '老李头'

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

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

lambda

lambda 方法是一个便捷的方法,它允许你从 QueryWrapperUpdateWrapper 对象中获取对应的 LambdaQueryWrapperLambdaUpdateWrapper 对象。这样,你就可以使用 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 表达式可以避免直接使用字符串来指定字段名,从而减少错误并提高代码的可读性。

使用提示

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

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

Wrappers

MyBatis-Plus 提供了 Wrappers 类,它是一个静态工厂类,用于快速创建 QueryWrapperUpdateWrapperLambdaQueryWrapperLambdaUpdateWrapper 的实例。使用 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, "李四");

线程安全性

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支持QueryWrapperUpdateWrapper,但不支持LambdaQueryWrapperLambdaUpdateWrapper。如果需要使用Lambda风格的Wrapper,可以使用KtQueryWrapperKtUpdateWrapper

参考示例:

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提供的功能。

Baomidou

© 2016-2024 Baomidou™. All Rights Reserved.

Power by Astro Starlight | Sponsored by JetBrains

渝ICP备2021000141号-1 | 渝公网安备50011302222097