Mybatis-plus进阶篇(四)

一.条件构造器方法

1.eqSql

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

方法签名

1
2
3
4
5
// 设置指定字段等于 SQL 语句的结果
eqSql(R column, String inValue)

// 在条件满足时设置指定字段等于 SQL 语句的结果
eqSql(boolean condition, R column, String inValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eqSql("id", "select MAX(id) from table");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eqSql(User::getId, "select MAX(id) from table");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id = (select MAX(id) from table)

注意事项:

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

2.gtSql

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

方法签名

1
2
3
4
5
// 设置指定字段大于 SQL 语句的结果
gtSql(R column, String inValue)

// 在条件满足时设置指定字段大于 SQL 语句的结果
gtSql(boolean condition, R column, String inValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gtSql("id", "select id from table where name = 'xx'");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.gtSql(User::getId, "select id from table where name = 'xx'");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id > (select id from table where name = 'xx')

注意事项:

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

3.geSql

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

方法签名

1
2
3
4
5
// 设置指定字段大于等于 SQL 语句的结果
geSql(R column, String inValue)

// 在条件满足时设置指定字段大于等于 SQL 语句的结果
geSql(boolean condition, R column, String inValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.geSql("id", "select id from table where name = 'xx'");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.geSql(User::getId, "select id from table where name = 'xx'");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id >= (select id from table where name = 'xx')

注意事项:

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

4.ltSql

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

方法签名

1
2
3
4
5
// 设置指定字段小于 SQL 语句的结果
ltSql(R column, String inValue)

// 在条件满足时设置指定字段小于 SQL 语句的结果
ltSql(boolean condition, R column, String inValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.ltSql("id", "select id from table where name = 'xx'");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ltSql(User::getId, "select id from table where name = 'xx'");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id < (select id from table where name = 'xx')

注意事项:

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

5.leSql

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

方法签名

1
2
3
4
5
// 设置指定字段小于等于 SQL 语句的结果
leSql(R column, String inValue)

// 在条件满足时设置指定字段小于等于 SQL 语句的结果
leSql(boolean condition, R column, String inValue)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.leSql("id", "select id from table where name = 'xx'");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.leSql(User::getId, "select id from table where name = 'xx'");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE id <= (select id from table where name = 'xx')

注意事项:

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

6.groupBy

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置分组条件，使用字段名
groupBy(R... columns)
groupBy(boolean condition, R... columns)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

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

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getId, User::getName);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY id, name

注意事项:

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

7.orderByAsc

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

// 设置升序排序条件，使用字段名
orderByAsc(R… columns)
orderByAsc(boolean condition, R… columns)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

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

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(User::getId, User::getName);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC

注意事项:

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

8.orderByDesc

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置降序排序条件，使用字段名
orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

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

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByDesc(User::getId, User::getName);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id DESC, name DESC

注意事项:

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

9.orderBy

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
// 设置排序条件，使用字段名和排序方向
orderBy(boolean condition, boolean isAsc, R... columns)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderBy(true, true, "id", "name");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderBy(true, true, User::getId, User::getName);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user ORDER BY id ASC, name ASC

注意事项:

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

10.having

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置 HAVING 子句，使用 SQL 语句和参数
having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.groupBy("age").having("sum(age) > 10");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.groupBy(User::getAge).having("sum(age) > {0}", 10);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user GROUP BY age HAVING sum(age) > 10

注意事项:

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

11.func

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 根据条件执行不同的查询构建逻辑
func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
3
4
5
6
7
8
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.func(i -> {
    if (true) {
        i.eq("id", 1);
    } else {
        i.ne("id", 1);
    }
});

Lambda Wrapper (LambdaQueryWrapper)：

1
2
3
4
5
6
7
8
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.func(i -> {
    if (true) {
        i.eq(User::getId, 1);
    } else {
        i.ne(User::getId, 1);
    }
});

生成的 SQL:

1
2
3
4
5
6
-- 根据条件生成的 SQL 会有所不同
-- 如果条件为 true，则生成的 SQL 为：
SELECT * FROM user WHERE id = 1

-- 如果条件为 false，则生成的 SQL 为：
SELECT * FROM user WHERE id != 1

注意事项:

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

12.or

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
6
7
// 改变后续查询条件的连接方式为 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)：

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

Lambda Wrapper (LambdaQueryWrapper)：

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

生成的 SQL:

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

OR 嵌套示例：

1
2
3
4
5
6
7
8
9
// 普通 Wrapper
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.or(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
                         .or(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"))
                              .or(j -> j.eq(User::getName, "杜甫").eq(User::getStatus, "alive")));

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status = 'alive') OR (name = '杜甫' AND status = 'alive')

注意事项:

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

13.and

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 添加 AND 嵌套条件
and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
3
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)：

1
2
3
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:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE ((name = '李白' AND status = 'alive') AND (name = '杜甫' AND status = 'alive'))

注意事项:

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

14.nested

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 添加一个独立的查询条件块
nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.nested(i -> i.eq("name", "李白").ne("status", "活着"));

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.nested(i -> i.eq(User::getName, "李白").ne(User::getStatus, "活着"));

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE (name = '李白' AND status <> '活着')

注意事项:

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

15.apply

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 拼接 SQL 片段
apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("id = 1");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'");

使用参数占位符的示例：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = {0}", "2008-08-08");

生成的 SQL

1
2
3
4
5
6
7
8
-- 普通 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'

注意事项:

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

16.last

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 在查询的最后添加一个 SQL 片段
last(String lastSql)
last(boolean condition, String lastSql)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.last("limit 1");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.last("limit 1");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user LIMIT 1

注意事项:

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

17.exists

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 添加 EXISTS 子查询
exists(String existsSql)
exists(boolean condition, String existsSql)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.exists("select id from table where age = 1");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.exists("select id from table where age = 1");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE EXISTS (select id from table where age = 1)

注意事项:

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

18.notExists

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

使用范围

QueryWrapper
LambdaQueryWrapper
UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 添加 NOT EXISTS 子查询
notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.notExists("select id from table where age = 1");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notExists("select id from table where age = 1");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT * FROM user WHERE NOT EXISTS (select id from table where age = 1)

注意事项:

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

19.select

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

使用范围

QueryWrapper
LambdaQueryWrapper

方法签名

1
2
3
4
5
6
// 设置查询字段
select(String... sqlSelect)

// 过滤查询字段（主键除外）
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

参数说明

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

示例

普通 Wrapper (QueryWrapper)：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("id", "name", "age");

Lambda Wrapper (LambdaQueryWrapper)：

1
2
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.select(User::getId, User::getName, User::getAge);

使用 Predicate 过滤字段的示例：

1
2
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select(i -> i.getProperty().startsWith("test"));

生成的 SQL:

1
2
3
4
5
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
SELECT id, name, age FROM user

-- 使用 Predicate 过滤字段生成的 SQL
SELECT testField1, testField2 FROM user

说明:

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

20.set

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

使用范围

UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 设置更新语句中的 SET 字段
set(R column, Object val)
set(R column, Object val, String mapping)
set(boolean condition, R column, Object val)
set(boolean condition, R column, Object val, String mapping)

参数说明

column：数据库字段名或使用 Lambda 表达式的字段名。
condition：一个布尔值，用于控制是否应用这个 SET 字段。
val：一个对象，表示要更新到字段的新值。
mapping：额外指定,例如: javaType=int,jdbcType=NUMERIC,typeHandler=xxx.xxx.MyTypeHandler

示例

普通 Wrapper (UpdateWrapper)：

1
2
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set("name", "老李头");

Lambda Wrapper (LambdaUpdateWrapper)：

1
2
LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.set(User::getName, "老李头");

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE user SET name = '老李头'

使用条件控制的示例：

1
2
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.set(true, "name", "");

生成的 SQL:

1
2
-- 使用条件控制的 SQL
UPDATE user SET name = ''

注意事项:

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

21.setSql

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

使用范围

UpdateWrapper
LambdaUpdateWrapper

方法签名

1
2
3
// 设置更新语句中的 SET 部分 SQL
setSql(String setSql, Object... params)
setSql(boolean condition, String setSql, Object... params)

参数说明

setSql：一个字符串，包含要作为 SET 子句的 SQL 片段。
condition：一个布尔值，用于控制是否应用这个 SET 字段。
params：一个可变参数列表，包含 SQL 片段中占位符的替换值。

示例

1
2
3
setSql("name = '老李头'")
setSql("dateColumn={0}", LocalDate.now())
setSql("type={0,javaType=int,jdbcType=NUMERIC,typeHandler=xxx.xxx.MyTypeHandler}", "待处理字符串");

注意事项:

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

22.setIncrBy

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

使用范围

LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 字段自增指定数值
setIncrBy(SFunction<T, ?> column, Number val)

// 在条件满足时字段自增指定数值
setIncrBy(boolean condition, SFunction<T, ?> column, Number val)

参数说明

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

示例

普通 Wrapper (UpdateWrapper)：

1
2
UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();
updateWrapper.setIncrBy(Product::getNum, 1);

Lambda Wrapper (LambdaUpdateWrapper)：

1
2
LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setIncrBy(Product::getNum, 1);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num + 1

注意事项:

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

23.setDecrBy

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

使用范围

LambdaUpdateWrapper

方法签名

1
2
3
4
5
// 字段自减指定数值
setDecrBy(SFunction<T, ?> column, Number val)

// 在条件满足时字段自减指定数值
setDecrBy(boolean condition, SFunction<T, ?> column, Number val)

参数说明

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

示例

普通 Wrapper (UpdateWrapper)：

1
2
UpdateWrapper<Product> updateWrapper = new UpdateWrapper<>();
updateWrapper.setDecrBy("num", 1);

Lambda Wrapper (LambdaUpdateWrapper)：

1
2
LambdaUpdateWrapper<Product> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
lambdaUpdateWrapper.setDecrBy(Product::getNum, 1);

生成的 SQL:

1
2
-- 普通 Wrapper 和 Lambda Wrapper 生成的 SQL 相同
UPDATE product SET num = num - 1

注意事项:

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

24.lambda

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

使用范围

QueryWrapper
UpdateWrapper

方法签名

1
2
// 获取 Lamdba Wrapper
lambda();

示例

从 QueryWrapper 获取 LambdaQueryWrapper：

1
2
3
4
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();
// 使用 Lambda 表达式构建查询条件
lambdaQueryWrapper.eq("name", "张三");

从 UpdateWrapper 获取 LambdaUpdateWrapper：

1
2
3
4
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
LambdaUpdateWrapper<User> lambdaUpdateWrapper = updateWrapper.lambda();
// 使用 Lambda 表达式构建更新条件
lambdaUpdateWrapper.set(User::getName, "李四");

说明

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

注意事项:

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