x
    //【条件构造器Wrapper -- 简介】

    /*

    为了清晰表示父类子类，我们用阶梯的形式写出来，如下

    Wrapper: 条件构造抽象类，最顶端父类
        AbstractWrapper: 用于查询条件封装。该类是抽象类，有三个子类
            QueryWrapper: 封装查询的条件。除了查询还用于删除
            UpdateWrapper: 封装修改的条件，还可以封装修改的字段
            AbstractLambdaWrapper: 该类是抽象类，可以使用Lambda语法。该类是抽象类，有两个子类
                LambdaQueryWrapper: 使用Lambda语法来封装查询的条件。。除了查询还用于删除
                LambdaUpdateWrapper: 使用Lambda语法来封装修改的条件

    注意: 无论是查询，删除、修改，都可使用QueryWrapper类，原因:UpdateWrapper、QueryWrapper、AbstractLambdaWrapper的父类是同一个
    注意: 下面叙述中的逻辑字段，如何判断逻辑字段对应的数据是否被删除。只需要看该逻辑字段的值即可，如果是0的话(我们创建逻辑字段时要求手动赋值为0)就表示未删除，如果是1就表示已经被逻辑删除


    */

    //下面我们会讲Wrapper的其中一个子类，也就是QueryWrapper


    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件查询selectList】

    /*

    selectList方法用于组装查询条件，具体操作如下:

    1. 在src/test/java/com.huanf.mybatisplus目录下新建MyBatisPlusWrapperTest测试类

    2. 在MyBatisPlusWrapperTest进行测试即可

    */

    //MyBatisPlusWrapperTest类写的代码如下:

    @SpringBootTest
    public class MyBatisPlusWrapperTest {

    @Autowired//作用是把要用到的成员变量进行自动装配。也就是引用我们UserMapper接口(我们在UserMapper接口继承了MyBatis-Plus提供的BaseMapper<User>接口)
    private UserMapper userMapper;

    @Test
    //条件查询selectList
    public void zidingyi_test1(){
        //需求: 查询用户名包含a，年龄在20到30之间，邮箱信息不为null的用户信息
        //由于Mapper类是最顶类，且是抽象类，所以我们需要使用Mapper类的子类，即创建'Mapper类的子类'的对象，因为是查询操作所以创建的是QueryWrapper类的对象
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<User>();
        zidingyi_queryWrapper.like("user_name","a")//下面可以紧接着进行链式编程。注意user_name是数据库的字段
            .between("age",20,30)//ge表示大于等于，le表示小于等于，between表示在什么之间。注意age是数据库的字段
            .isNotNull("email");//isNotNull表示某个字段不为空。链式编程结束之后分号结尾。注意email是数据库的字段
        //上面四行的意思: 先创建指定的条件构造器queryWrapper，再使用链式编程把条件构造器赋予各种条件。最后把赋值好的条件构造器放到下面那行
        List<User> list = userMapper.selectList(zidingyi_queryWrapper);//返回值是list集合
        //由于要输出集合，所以我们需要使用到forEach遍历输出
        list.forEach(System.out::println);

    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，且你在逻辑操作时删过k条数据，那么即使k条数据符合上面条件查询的条件，k条数据也不会被查询出来
    //可以理解为你之前对逻辑字段的操作虽然对数据库没有真正影响，但是对条件查询是有影响的
}


    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件查询selectList -- 组装排序条件】

      //MyBatisPlusWrapperTest类，添加如下:

      @Test
      //条件查询selectList-组装排序条件
      public void zidingyi_test2(){
          //需求: 查询用户信息，按照年龄的降序排序，若年龄相同，则按照id升序排序
          //由于Mapper类是最顶类，且是抽象类，所以我们需要使用Mapper类的子类，即创建'Mapper类的子类'的对象，因为是查询操作所以创建的是QueryWrapper类的对象
          QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<User>();
          zidingyi_queryWrapper.orderByDesc("age")//asc升序(默认就是这个)，desc降序
                  .orderByAsc("uid");//注意age和uid都是数据库的字段名，一定要看看你的数据库字段名是不是叫这个。同样可以用链式编程
          List<User> list = userMapper.selectList(zidingyi_queryWrapper);//返回值是list集合
          //由于要输出集合，所以我们需要使用到forEach遍历输出
          list.forEach(System.out::println);
      }

    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件删除delete】


    @Test
    //条件删除
    public void zidingyi_test3(){
        //需求: 删除邮箱地址为null的用户信息
        //由于Mapper类是最顶类，且是抽象类，所以我们需要使用Mapper类的子类，即创建'Mapper类的子类'的对象，因为是删除操作所以创建的是QueryWrapper类的对象
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<User>();
        zidingyi_queryWrapper.isNull("email");//isnNull表示要求哪个字段为空。由于只有一个条件所以不需要使用链式编程
        int result = userMapper.delete(zidingyi_queryWrapper);//返回值是受影响的行数
        System.out.println("受影响的行数是"+result);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，此时执行这里的删除方法，但是数据并不会真正删除，只是逻辑上的删除
    //虽然我们查询的时候数据是被删除(也就是查询不到)的，但是数据不会被真正删除
    
    //注意当要删除的数据没有逻辑字段时，那么就会被真正删除

    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件修改】


    @Test
    //条件修改update
    public void zidingyi_test4(){
        //需求: 将(年龄大于20并且用户名中包含有a)或邮箱为null的用户信息修改
        //由于Mapper类是最顶类，且是抽象类，所以我们需要使用Mapper类的子类，即创建'Mapper类的子类'的对象，因为是修改操作所以创建的是QueryWrapper类的对象
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<>();
        zidingyi_queryWrapper.gt("age",20)//gt表示大于等于，也就是年龄要大于等于20
                .like("user_name","a")//表示用户名中包含有a，注意链式编程中的默认连接的条件是and，所以默认就有并且的关系
                .or()//注意此时就要指定连接条件，不能使用默认的and条件，因为需求是'或'。连接条件: 链式编程的多条链，每一条链就是一个条件，这些条件的关系要么是and(默认)、or、not
                .isNull("email");//链式编程结束之后，用分号结尾
        //由于update方法需要一个实体类(User)的对象,然后把你想修改后的值赋值到这个对象里面
        User user = new User();
        user.setName("小明");
        user.setEmail("update@123.com");
        int result = userMapper.update(user, zidingyi_queryWrapper);//返回值是受影响的行数。zidingyi_queryWrapper表示你要修改的数据要具备什么条件，user是修改后的数据
        System.out.println("受影响的行数是"+result);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，并且k数据已经被逻辑删除了，那么此时执行这里的修改方法，k数据即使符合条件也不会被修改

    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件修改】

    @Test
    //条件修改update
    public void zidingyi_test4(){
        //需求: 将(年龄大于20并且用户名中包含有a)或邮箱为null的用户信息修改
        //由于Mapper类是最顶类，且是抽象类，所以我们需要使用Mapper类的子类，即创建'Mapper类的子类'的对象，因为是修改操作所以创建的是QueryWrapper类的对象
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<>();
        zidingyi_queryWrapper.gt("age",20)//gt表示大于等于，也就是年龄要大于等于20
                .like("user_name","a")//表示用户名中包含有a，注意链式编程中的默认连接的条件是and，所以默认就有并且的关系
                .or()//注意此时就要指定连接条件，不能使用默认的and条件，因为需求是'或'。连接条件: 链式编程的多条链，每一条链就是一个条件，这些条件的关系要么是and(默认)、or、not
                .isNull("email");//链式编程结束之后，用分号结尾
        //由于update方法需要一个实体类(User)的对象,然后把你想修改后的值赋值到这个对象里面
        User user = new User();
        user.setName("小明");
        user.setEmail("update@123.com");
        int result = userMapper.update(user, zidingyi_queryWrapper);//返回值是受影响的行数。zidingyi_queryWrapper表示你要修改的数据要具备什么条件，user是修改后的数据
        System.out.println("受影响的行数是"+result);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，并且k数据已经被逻辑删除了，那么此时执行这里的修改方法，k数据即使符合条件也不会被修改

    ----------------------------------------------


    //【条件构造器Wrapper -- QueryWrapper类的条件的优先级】

    @Test
    //条件的优先级
    public void zidingyi_test5(){
        //需求: 将用户名中包含a并且(年龄大于20或邮箱为null)的用户信息修改
        //难点: 需要优先判断括号里的'年龄大于20或邮箱为null'条件
        //突破点: 在条件构造器中，Lambda表达式里面的条件优先执行，也就是优先级最高，且Lambda表达式内部也可以使用链式编程
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<>();
        zidingyi_queryWrapper.like("user_name","a")
                .and(i->i.gt("age",20).or().isNull("email"));//用Lambda表达式，i表示条件构造器，我们可以通过i调用方法
        //由于update方法需要一个实体类(User)的对象,然后把你想修改后的值赋值到这个对象里面
        User user = new User();
        user.setName("小红");
        user.setEmail("youxianji@123.com");
        int result = userMapper.update(user, zidingyi_queryWrapper);//返回值是受影响的行数
        System.out.println("受影响的行数是"+result);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，并且k数据已经被逻辑删除了，那么此时执行这里的修改方法，k数据即使符合条件也不会被修改

    ----------------------------------------------


    //【条件构造器Wrapper -- 组装查询语句，简单说就是怎么写查询条件】

    @Test
    //组装select字句
    public void zidingyi_test6(){
        //需求: 查询用户的用户名、年龄、邮箱
        //难点: 不是查询所有字段的数据，查询的是指定字段的数据
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<>();
        zidingyi_queryWrapper.select("user_name","age","email");
        //下面那行的右边获取上面那行的条件构造器对象，然后返回值是List<Map>，表示获取的数据是Map集合，最后返回的字段是List集合
        List<Map<String,Object>> mapList = userMapper.selectMaps(zidingyi_queryWrapper);
        //由于是List集合，所以我们需要forEach遍历输出
        mapList.forEach(System.out::println);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，并且k数据已经被逻辑删除了，那么此时执行这里的查询方法，k数据即使符合条件也不会被查询到

    ----------------------------------------------


    //【条件构造器Wrapper -- 组装子查询语句，简单说就是怎么写子查询条件】

    @Test
    //组装子查询语句，简单说就是怎么写子查询条件
    public void zidingyi_test7(){
        //需求: 查询uid小于等于3的用户信息
        //难点: 用子查询实现
        QueryWrapper<User> zidingyi_queryWrapper = new QueryWrapper<>();
        zidingyi_queryWrapper.inSql("uid","select uid from t_user where uid <= 3");
        //下面那行的右边获取上面那行的条件构造器对象，然后返回值是List集合
        List<User> list = userMapper.selectList(zidingyi_queryWrapper);
        //由于是List集合，所以我们需要forEach遍历输出
        list.forEach(System.out::println);
    }
    //注意如果k条数据里有逻辑字段，并且逻辑字段不为空，并且k数据已经被逻辑删除了，那么此时执行这里的查询方法，k数据即使符合条件也不会被查询到