mybatisPlus进阶篇

移动开发 2023-07-30 11:32:49 阅读次数: 0

文章目录

映射

  • Mybatis框架之所以能够简化数据库操作，是因为内部的映射机制，通过自动映射，进行数据的封装，我们只要符合映射规则，就可以快速高效的完成SQL操作的实现。
  • 既然MybatisPlus是基于Mybatis的增强工具，所以也具有这样的映射规则。

自动映射规则

  1. 表名和实体类名映射 -> 表名user 实体类名User
  2. 字段名和实体类属性名映射 -> 字段名name 实体类属性名name
  3. 字段名下划线命名方式和实体类属性小驼峰命名方式映射 -> 字段名 user_email 实体类属性名 userEmail
  • MybatisPlus支持这种映射规则，可以通过配置来设置
map-underscore-to-camel-case: true #表示支持下划线到驼峰的映射
map-underscore-to-camel-case: false #表示不支持下划线到驼峰的映射

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true

表映射

  • 通过@TableName()注解指定映射的数据库表名，就会按照指定的表名进行映射。如：此时将数据库的表名改为powershop_user,要完成表名和实体类名的映射，需要将实体类名也要指定为powershop_user
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("powershop_user")
public class User {
    
    
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
  • 如果有很多实体类，对应到数据库中的很多表，我们不需要每个依次配置，只需要配置一个全局的设置，他都会给每个实体类名前面添加指定的前缀，这里我们演示一下全局配置的效果
mybatis-plus:
  global-config:
    db-config:
      table-prefix: powershop_

字段映射

  1. 当数据库字段和表实体类的属性不一致时，可以使用@TableField()注解改变字段和属性的映射，让注解中的名称和表字段保持一致。 如：此时将数据库字段的名称我们改为username，在根据实体类的属性拼接SQL的使用，就会使用@TableField()中指定的名称username进行拼接，完成查询
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    @TableField("username")
    private String name;
   }
  • 此时的SQL语句
SELECT id,username AS name,email FROM powershop_user
  1. 数据库字段和表实体类的属性一致，框架在拼接SQL语句的时候，会使用属性名称直接拼接sql语句，例如：
SELECT  id,username AS name,age,email,desc  FROM powershop_user

这条语句直接进行查询的时候，会出现错误

Error querying database.  Cause: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; 
check the manual that corresponds to your MySQL server version 
for the right syntax to use near 'desc  FROM powershop_user' at line 1
  • 原因：desc属于关键字，不能直接用于sql查询，要解决这个问题，就需要将desc字段加上``符号，将他变为不是关键字，才能完成查询，那这个问题的根本也是改变生成的SQL语句的字段名称，也就是我们需要通过@TableField()改变实体类的属性名称，将desc变为desc,就可以解决这个问题
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    @TableField("`desc`")
    private String desc;
}

在这里插入图片描述

字段失效

  • 当数据库中有字段不希望被查询，我们可以通过@TableField(select = false)来隐藏这个字段，那在拼接SQL语句的时候，就不会拼接这个字段
  • 如：如果不想显示年龄信息，那么可以在age属性上添加这个注解，来隐藏这个字段
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    @TableField(select = false)
    private Integer age;
}
  • 生成的SQL语句如下
    在这里插入图片描述

视图属性

  • 在实际开发中，有些字段不需要数据库存储，但是却需要展示，需要展示也就是意味着实体类中需要存在这个字段，我们称这些实体类中存在但是数据库中不存在的字段，叫做视图字段。

  • 根据之前的经验，框架会默认将实体类中的属性作为查询字段进行拼接。像这种视图字段，不能作为查询条件么。因为数据库中没有这个字段，所以查询字段如果包含这个字段，SQL语句会出现问题。我们通过@TableField(exist = false)来去掉这个字段，不让其作为查询字段。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    @TableField(exist = false)
    private Integer online;
}
  • 可以看到查询结果中不包含该字段
    在这里插入图片描述

条件构造器

条件构造器介绍

  • 想要使用MybatisPlus完成条件查询，基于面向对象的思想，万物皆对象，那么查询条件也需要使用对象来完成封装。理清楚MybatisPlus中，和条件有关的类以及其之关系,在传递条件对象的时候，更有助于理清思路。
  1. Wrapper——抽象类，条件类的顶层，提供了一些获取和判断相关的方法
  2. AbstractWrapper——抽象类，Wrapper的子类，提供了所有的条件相关方法
  3. AbstractLambdaWrapper——抽象类，AbstractWrapper的子类，确定字段参数为方法引用类型
  4. QueryWrapper——AbstractWrapper的子类，如果需要传递String类型的字段信息，创建该对象
  5. LambdaQueryWrapper——AbstractLambdaWrapper的子类，如果需要传递方法引用方式的字段信息，创建该对象

在这里插入图片描述

  • 该图为以上各类的关系，在编写代码的时候，只需要关注QueryWrapper和LambdaQueryWrapper

  • 需要重点掌握QueryWrapper和LambdaQueryWrapper这两个类，在一般情况下，大多选择LambdaQueryWrapper，因为选择这种方式传递参数，不用担心拼写错误问题。

等值查询

eq

  • 使用QueryWrapper对象，构建查询条件
@Test
void eq(){
    
    
    //1.创建QueryWrapper对象
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //2.设置条件，指定String字段名称和值
    queryWrapper.eq("name","Jack");
    //3.使用条件完成查询
    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);
}

测试效果
在这里插入图片描述

  • 如果每次都是自己进行字段名称的编写，有可能会出现名称写错的情况，为避免这种情况，可以使用LambdaQueryWrapper对象，在构建字段时，使用方法引用的方式来选择字段，这样做可以避免字段拼写错误出现问题。
    代码如下：
@Test
void eq2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定String字段名称和值
    lambdaQueryWrapper.eq(User::getName,"Jack");
    //3.使用条件完成查询
    User user = userMapper.selectOne(lambdaQueryWrapper);
    System.out.println(user);
}

  • 有时不能确定所有的条件都是有值的，部分条件可能用户没有传值，那该条件就为null。为null的条件，是不需要进行查询条件拼接的，否则就会出现如下情况，将为null的条件进行拼接，筛选后无法查询出结果

  • 要解决这个问题，可以先判断是否为空，根据判断结果选择是否拼接该字段

@Test
void isNull2(){
    
    
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    String name = null;
    lambdaQueryWrapper.eq(name != null,User::getName,name);
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

allEq

  • 先演示一下通过多个eq,构建多条件查询
@Test
void allEq1(){
    
    
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.eq(User::getName,"Jone");
    lambdaQueryWrapper.eq(User::getAge,18);

    User user = userMapper.selectOne(lambdaQueryWrapper);
    System.out.println(user);
}
  • 如果此时有多个条件需要同时判断，可以将这多个条件放入到Map集合中，更加的方便
@Test
void allEq2(){
    
    
    //1.创建QueryWrapper对象
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    //2.构建条件Map
    HashMap<String, Object> hashMap = new HashMap<>();
    hashMap.put("name","Jone");
    hashMap.put("age",null);

    //3.使用条件完成查询
    queryWrapper.allEq(hashMap,false);
    User user = userMapper.selectOne(queryWrapper);
    System.out.println(user);
}

allEq(Map<R, V> params, boolean null2IsNull)
  • 参数params：表示传递的Map集合
  • 参数null2IsNull：表示对于为null的条件是否判断isNull

ne

@Test
void ne(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定String字段名称和值
    String name = "Jone";
    lambdaQueryWrapper.ne(User::getName,name);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下:
    在这里插入图片描述

范围查询

gt

@Test
void gt(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    Integer age = 18;
    lambdaQueryWrapper.gt(User::getAge,age);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

ge(>=)

@Test
void ge(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    Integer age = 18;
    lambdaQueryWrapper.ge(User::getAge,age);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

lt(<)

@Test
void lt(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    Integer age = 18;
    lambdaQueryWrapper.lt(User::getAge,age);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

le(<=)

@Test
void le(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    Integer age = 18;
    lambdaQueryWrapper.le(User::getAge,age);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

between

@Test
void between(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.between(User::getAge,18,30);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

notBetween

@Test
void notBetween(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notBetween(User::getAge,18,30);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

模糊查询

like

@Test
void like(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.like(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

notLike

@Test
void notLike(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notLike(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

likeLeft

@Test
void likeLeft(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.likeLeft(User::getName,"e");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

likeRight

@Test
void likeRight(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.likeLeft(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

判空查询

isNull

@Test
void isNull(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称
    lambdaQueryWrapper.isNull(User::getName);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

isNotNull

@Test
void isNotNull(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称
    lambdaQueryWrapper.isNotNull(User::getName);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

包含查询

in

@Test
void in(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    ArrayList<Integer> arrayList = new ArrayList<>();
    Collections.addAll(arrayList,18,20,21);
    lambdaQueryWrapper.in(User::getAge,arrayList);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

@Test
void in2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.in(User::getAge,18,20,21);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

拼接的SQL如下
在这里插入图片描述

notIn

@Test
void notIn(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    ArrayList<Integer> arrayList = new ArrayList<>();
    Collections.addAll(arrayList,18,20,21);
    lambdaQueryWrapper.notIn(User::getAge,arrayList);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

@Test
void notIn2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notIn(User::getAge,18,20,21);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

inSql

@Test
void inSql(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.inSql(User::getAge,"18,20,22");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述
@Test
void inSql2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.inSql(User::getAge,"select age from powershop_user where age > 20");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

notInSql

@Test
void notInSql(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notInSql(User::getAge,"18,20,21");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述
@Test
void notInSql2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notInSql(User::getAge,"select age from powershop_user where age > 20");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

分组查询

groupBy

@Test
void groupBy(){
    
    
    //1.创建QueryWrapper对象
   QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //2.设置条件，指定字段名称和值
    queryWrapper.groupBy("age");
    queryWrapper.select("age,count(*) as field_count");
    //3.使用条件完成查询
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    System.out.println(maps);
}
  • 拼接的SQL如下
    在这里插入图片描述
  • 实际查询结果
    在这里插入图片描述
  • 封装结果
    在这里插入图片描述

聚合查询

having

@Test
void having(){
    
    
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //分组字段
    queryWrapper.groupBy("age");
    //查询字段
    queryWrapper.select("age,count(*) as field_count");
    //聚合条件筛选
    queryWrapper.having("field_count = 1");
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    System.out.println(maps);
}
  • 拼接的SQL如下
    在这里插入图片描述

排序查询

orderByAsc

@Test
void orderByAsc(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定升序排序字段
    lambdaQueryWrapper.orderByAsc(User::getAge,User::getId);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

orderByDesc

@Test
void orderByDesc(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定降序排序字段
    lambdaQueryWrapper.orderByDesc(User::getAge,User::getId);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

orderBy

@Test
void orderBy(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定降序排序字段
    lambdaQueryWrapper.orderBy(true,true,User::getId);
    lambdaQueryWrapper.orderBy(true,false,User::getAge);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

func查询

func

@Test
void func(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建逻辑判断语句
    lambdaQueryWrapper.func(i -> {
    
    
        if(true) {
    
    
            i.eq(User::getId, 1);
        }else {
    
    
            i.ne(User::getId, 1);
        }
    });
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

逻辑查询

and

  • 正常拼接默认就是and
@Test
void and(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30);
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述
  • and也可以进行嵌套
@Test
void and2(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.eq(User::getName,"wang").and(i -> i.gt(User::getAge,26).or().lt(User::getAge,22));
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

or

@Test
void or(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.lt(User::getAge,20).or().gt(User::getAge,23);
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

  • 拼接的SQL如下
    在这里插入图片描述

  • OR嵌套

@Test
void or2(){
    
    
     LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
     lambdaQueryWrapper.eq(User::getName,"wang").or(i -> i.gt(User::getAge,22).lt(User::getAge,26));
     List<User> users = userMapper.selectList(lambdaQueryWrapper);
     System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

nested

@Test
void nested(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.nested(i -> i.eq(User::getName, "Billie").ne(User::getAge, 22));
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

自定义条件查询

apply

@Test
void apply(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.apply("id = 1");
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

last查询

last

@Test
void last(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.last("limit 0,2");
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

exists查询

exists

@Test
void exists(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.exists("select id from powershop_user where age = 18");
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

notExists

@Test
void notExists(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.notExists("select id from powershop_user where age = 33");
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

字段查询

select

@Test
void select(){
    
    
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.select(User::getId,User::getName);
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
  • 拼接的SQL如下
    在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/yang2330648064/article/details/131941099
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022