Mybatis-plus进阶篇(二)

一.条件构造器方法

1.eq

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的相等条件
eq(R column, Object val)

// 根据条件设置指定字段的相等条件
eq(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "老王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName, "老王");

生成的 SQL：

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name = '老王'

2.ne

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的不相等条件
ne(R column, Object val)

// 根据条件设置指定字段的不相等条件
ne(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ne("name", "老王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ne(User::getName, "老王");

生成的 SQL：

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name <> '老王'

3.gt

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的大于条件
gt(R column, Object val)

// 根据条件设置指定字段的大于条件
gt(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 18);

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gt(User::getAge, 18);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age > 18

注意:

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

4.ge

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的大于等于条件
ge(R column, Object val)

// 根据条件设置指定字段的大于等于条件
ge(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ge("age", 18);

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ge(User::getAge, 18);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age >= 18

注意事项:

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

5.lt

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的小于条件
lt(R column, Object val)

// 根据条件设置指定字段的小于条件
lt(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.lt("age", 18);

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.lt(User::getAge, 18);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age < 18

注意事项:

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

6.le

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的小于等于条件
le(R column, Object val)

// 根据条件设置指定字段的小于等于条件
le(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.le("age", 18);

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.le(User::getAge, 18);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age <= 18

注意事项:

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

7.between

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的 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)：

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

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.between(User::getAge, 18, 30);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age BETWEEN 18 AND 30

注意事项:

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

8.notBetween

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的 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)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notBetween("age", 18, 30);

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notBetween(User::getAge, 18, 30);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT BETWEEN 18 AND 30

注意事项:

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

9.like

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的 LIKE 条件
like(R column, Object val)

// 根据条件设置指定字段的 LIKE 条件
like(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王%'

注意事项:

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

10.notLike

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的 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)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLike("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLike(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王%'

注意事项:

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

11.likeLeft

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的右模糊匹配条件
likeLeft(R column, Object val)

// 根据条件设置指定字段的右模糊匹配条件
likeLeft(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeLeft("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeLeft(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '%王'

注意事项:

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

12.likeRight

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的左模糊匹配条件
likeRight(R column, Object val)

// 根据条件设置指定字段的左模糊匹配条件
likeRight(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeRight("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeRight(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name LIKE '王%'

注意事项:

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

13.notLikeLeft

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的非右模糊匹配条件
notLikeLeft(R column, Object val)

// 根据条件设置指定字段的非右模糊匹配条件
notLikeLeft(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeLeft("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeLeft(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '%王'

注意事项:

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

14.notLikeRight

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的非左模糊匹配条件
notLikeRight(R column, Object val)

// 根据条件设置指定字段的非左模糊匹配条件
notLikeRight(boolean condition, R column, Object val)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notLikeRight("name", "王");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLikeRight(User::getName, "王");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name NOT LIKE '王%'

注意事项:

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

15.isNull

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置指定字段的 IS NULL 条件
isNull(R column)

// 根据条件设置指定字段的 IS NULL 条件
isNull(boolean condition, R column)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("name");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.isNull(User::getName);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE name IS NULL

注意事项:

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

16.in

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
6
7
// 设置指定字段的 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)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("age", Arrays.asList(1, 2, 3));

Lambda Wrapper (LambdaQueryWrapper)：

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

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3)

注意事项:

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

17.notIn

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
6
7
// 设置指定字段的 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)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notIn("age", Arrays.asList(1, 2, 3));

Lambda Wrapper (LambdaQueryWrapper)：

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

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3)

注意事项:

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

18.inSql

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置指定字段的 IN 条件，使用 SQL 语句
inSql(R column, String sqlValue)
inSql(boolean condition, R column, String sqlValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("age", "1,2,3,4,5,6");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge, "1,2,3,4,5,6");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)

使用子查询的示例：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.inSql("id", "select id from other_table where id < 3");

生成的 SQL:

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

注意事项:

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

19.notInSql

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置指定字段的 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)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("age", "1,2,3,4,5,6");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge, "1,2,3,4,5,6");

生成的 SQL

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)

使用子查询的示例：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notInSql("id", "select id from other_table where id < 3");

生成的 SQL

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

注意事项:

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