Mybatis plus：Wrapper接口

一、介绍

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

Wrapper ：条件构造抽象类，最顶端父类
AbstractWrapper ：这是一个抽象基类，提供了所有 Wrapper 类共有的方法和属性。它定义了条件构造的基本逻辑，包括字段（column）、值（value）、操作符（condition）等。所有的 QueryWrapper、UpdateWrapper、LambdaQueryWrapper 和 LambdaUpdateWrapper 都继承自 AbstractWrapper。
QueryWrapper ：专门用于构造查询条件，支持基本的等于、不等于、大于、小于等各种常见操作。它允许你以链式调用的方式添加多个查询条件，并且可以组合使用 and 和 or 逻辑。
UpdateWrapper ：用于构造更新条件，可以在更新数据时指定条件。与 QueryWrapper 类似，它也支持链式调用和逻辑组合。使用 UpdateWrapper 可以在不创建实体对象的情况下，直接设置更新字段和条件。
AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
LambdaQueryWrapper ：这是一个基于 Lambda 表达式的查询条件构造器，它通过 Lambda 表达式来引用实体类的属性，从而避免了硬编码字段名。这种方式提高了代码的可读性和可维护性，尤其是在字段名可能发生变化的情况下。
LambdaUpdateWrapper ：类似于 LambdaQueryWrapper，LambdaUpdateWrapper 是基于 Lambda 表达式的更新条件构造器。它允许你使用 Lambda 表达式来指定更新字段和条件，同样避免了硬编码字段名的问题。

二、Wrapper使用

1、allEq() 多个字段相等

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.allEq(Map.of("id", 1, "name", "老王", "age", null));
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        Map<SFunction<User,?>, Object> map = new HashMap<>();
        map.put(User::getId,1);
        map.put(User::getName,"老王");
        map.put(User::getAge,null);
        lambdaQueryWrapper.allEq(map);

        //生成的sql： SELECT * FROM user WHERE id = 1 AND name = '老王' AND age IS NULL
    }

2、eq() 相等

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", "老王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName, "老王");

        //生成的sql： SELECT * FROM user WHERE name = '老王'
    }

3、ne() 不相等

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("name", "老王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.ne(User::getName, "老王");

        //生成的sql： SELECT * FROM user WHERE name <> '老王'
    }

4、gt() 大于

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age > 18
    }

5、ge() 大于等于

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age >= 18
    }

6、lt() 小于

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age < 18
    }

7、le() 小于等于

public void test() {
        // 普通 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： SELECT * FROM user WHERE age <= 18
    }

8、between

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age BETWEEN 18 AND 30
    }

9、notBetween

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age NOT BETWEEN 18 AND 30
    }

10、like %val%

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name LIKE '%王%'
    }

11、not like %val%

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.notLike("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notLike(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name NOT LIKE '%王%'
    }

12、likeLeft %val

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeLeft("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.likeLeft(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name LIKE '%王'
    }

13、likeRight val%

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.likeRight("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.likeRight(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name LIKE '王%'
    }

14、notLikeLeft

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.notLikeLeft("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notLikeLeft(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name NOT LIKE '%王'
    }

15、notLikeRight

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.notLikeRight("name", "王");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.notLikeRight(User::getName, "王");

        //生成的sql： SELECT * FROM user WHERE name NOT LIKE '王%'
    }

16、isNull

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("name");
        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.isNull(User::getName);

        //生成的sql： SELECT * FROM user WHERE name IS NULL
    }

17、in

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age IN (1, 2, 3)
    }

18、notIn

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age NOT IN (1, 2, 3)
    }

19、inSql

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age IN (1, 2, 3, 4, 5, 6)

        // 使用子查询的示例：
        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)
    }

20、notInSql

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

public void test() {
        // 普通 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： SELECT * FROM user WHERE age NOT IN (1, 2, 3, 4, 5, 6)

        // 使用子查询的示例：
        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)
    }

21、eqSql gtSql geSql ltSql leSql 要求版本3.4.3.2以后

以上都是MyBatis-Plus 中用于构建查询条件的高级方法之一，可以使用子查询。

22、groupBy

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

public void test() {
        // 普通 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： SELECT * FROM user GROUP BY id, name
    }

23、orderByAsc

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

public void test() {
        // 普通 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： SELECT * FROM user ORDER BY id ASC, name ASC
    }

24、orderByDesc

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

public void test() {
        // 普通 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： SELECT * FROM user ORDER BY id DESC, name DESC
    }

25、orderBy

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

public void test() {
        // 普通 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： SELECT * FROM user ORDER BY id ASC, name ASC
    }

26、having

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

public void test() {
        // 普通 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： SELECT * FROM user GROUP BY age HAVING sum(age) > 10
    }

27、func

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

public void test() {
        // 普通 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);
            }
        });

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

28、or

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

public void test() {
        // 普通 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：SELECT * FROM user WHERE id = 1 OR name = '老王'

        // OR 嵌套示例：
        queryWrapper.or(i -> i.and(j -> j.eq("name", "李白").eq("status", "alive"))
                .and(j -> j.eq("name", "杜甫").eq("status", "alive")));

        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：SELECT * FROM user WHERE (name = '李白' AND status = 'alive') OR (name = '杜甫' AND status = 'alive')
    }

29、and

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

public void test() {
        // 普通 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：SELECT * FROM user WHERE ((name = '李白' AND status = 'alive') AND (name = '杜甫' AND status = 'alive'))
    }

30、nested

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

public void test() {
        // 普通 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：SELECT * FROM user WHERE (name = '李白' AND status <> '活着')
    }

31、apply

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.apply("id = 1");
        // 生成的 SQL：SELECT * FROM user WHERE id = 1

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

        // 使用参数占位符的示例：
        queryWrapper.apply("date_format(dateColumn, '%Y-%m-%d') = {0}", "2008-08-08");

        // 生成的 SQL：SELECT * FROM user WHERE date_format(dateColumn, '%Y-%m-%d') = '2008-08-08'
    }

32、last

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.last("limit 1");

        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.last("limit 1");

        // 生成的 SQL：SELECT * FROM user LIMIT 1
    }

33、exists

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

public void test() {
        // 普通 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：SELECT * FROM user WHERE EXISTS (select id from table where age = 1)
    }

34、notExists

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

public void test() {
        // 普通 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：SELECT * FROM user WHERE NOT EXISTS (select id from table where age = 1)
    }

35、select

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

public void test() {
        // 普通 Wrapper (QueryWrapper)：
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id", "name", "age");

        // Lambda Wrapper (LambdaQueryWrapper)：
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.select(User::getId, User::getName, User::getAge);

        // 生成的 SQL：SELECT id, name, age FROM user

        // 使用 Predicate 过滤字段的示例：
        queryWrapper.select(i -> i.getProperty().startsWith("test"));

        // 生成的 SQL：SELECT testField1, testField2 FROM user
    }

36、set `UpdateWrapper`

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

public void test() {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("name", "老李头");

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

        // 生成的 SQL：UPDATE user SET name = '老李头'

        // 使用条件控制的示例：
        updateWrapper.set(true, "name", "");

        // 生成的 SQL：UPDATE user SET name = ''
    }

37、setSql `UpdateWrapper`

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

public void test() {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.setSql("name = '老李头'");

        LambdaUpdateWrapper<User> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        lambdaUpdateWrapper.setSql("name = '老李头'");

        // 生成的 SQL：UPDATE user SET name = '老李头'
    }

38、setIncrBy 自增 setDecrBy 自减

该方法需要版本在3.5.6以上。

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

39、lambda

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

public void test() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        LambdaQueryWrapper<User> lambdaQueryWrapper = queryWrapper.lambda();
        // 使用 Lambda 表达式构建查询条件
        lambdaQueryWrapper.eq(User::getName, "张三");

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

40、Wrappers

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

public void test() {
        // 创建 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, "李四");
    }