映射和条件构造器
2023-07-28 18:24:30 103浏览
1. 映射 28
学习过Mybatis的同学应该知道,Mybatis框架之所以能够简化数据库操作,是因为他内部的映射机制,通过自动映射,进行数据的封装,我们只要符合映射规则,就可以快速高效的完成SQL操作的实现。
既然MybatisPlus是基于Mybatis的增强工具,所以也具有这样的映射规则。
我们先来了解一下自动映射规则。
1.1 自动映射规则 29
【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
1.2 表映射 30-31
去数据库将user表名改为powershop_user
随便运行一个程序(单元测试中的UserMapper查询所有selectList方法),他说user表找不到
通过@TableName()注解指定映射的数据库表名,就会按照指定的表名进行映射
如:此时将数据库的表名改为powershop_user,要完成表名和实体类名的映射,需要将实体类名也要指定为powershop_user
package com.powernode.domain;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//数据库对应的实体类user 4
@Data //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射 30
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.3 字段映射 32
将表中的name字段改为username
执行一个程序,说name它找不到
什么场景下会改变字段映射呢?
当数据库字段和表实体类的属性不一致时
我们可以使用@TableField()注解改变字段和属性的映射,让注解中的名称和表字段保持一致
如:此时将数据库字段的名称我们改为username,在根据实体类的属性拼接SQL的使用,就会使用@TableField()中指定的名称username进行拼接,完成查询
package com.powernode.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//数据库对应的实体类user 4
@Data //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射 30
public class User {
private Long id;
@TableField("username") //指定表中的字段名和属性对应 32
private String name;
private Integer age;
private String email;
}
此时的SQL语句是这样的
SELECT id,username AS name,email FROM powershop_user
字段名和关键字相同时 33
我们在表中添加一个desc列
【2】数据库字段和表实体类的属性一致,框架在拼接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`,就可以解决这个问题
package com.powernode.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//数据库对应的实体类user 4
@Data //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射 30
public class User {
private Long id;
@TableField("username") //指定表中的字段名和属性对应 32
private String name;
private Integer age;
private String email;
@TableField("`desc`") //将desc字段变成普通字段 33
private String desc;
}
此时可以观察到,框架拼接生成的SQL语句的字段名称变为了`desc`,这样是可以正常完成查询的
1.4 字段失效 34
当数据库中有字段不希望被查询,我们可以通过@TableField(select = false)来隐藏这个字段,那在拼接SQL语句的时候,就不会拼接这个字段
如:如果不想显示年龄信息,那么可以在age属性上添加这个注解,来隐藏这个字段
package com.powernode.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//数据库对应的实体类user 4
@Data //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射 30
public class User {
private Long id;
@TableField("username") //指定表中的字段名和属性对应 32
private String name;
@TableField(select = false)//时age字段失效查询不到 34
private Integer age;
private String email;
@TableField("`desc`") //将desc字段变成普通字段 33
private String desc;
}
生成的SQL语句如下,通过查询生成的SQL语句,发现并没有拼接age字段
1.5 视图属性 35
在实际开发中,有些字段不需要数据库存储,但是却需要展示,需要展示也就是意味着实体类中需要存在这个字段,我们称这些实体类中存在但是数据库中不存在的字段,叫做视图字段。
根据之前的经验,框架会默认将实体类中的属性作为查询字段进行拼接,那我们来思考,像这种视图字段,能够作为查询条件么,显示是不能的。因为数据库中没有这个字段,所以查询字段如果包含这个字段,SQL语句会出现问题。我们通过@TableField(exist = false)来去掉这个字段,不让他作为查询字段。
package com.powernode.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//数据库对应的实体类user 4
@Data //生成set get方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
//@TableName("powershop_user") //指定数据库中的powershop_user表和这个User实体类映射 30
public class User {
private Long id;
@TableField("username") //指定表中的字段名和属性对应 32
private String name;
// @TableField(select = false)//时age字段失效查询不到 34
private Integer age;
private String email;
// @TableField("`desc`") //将desc字段变成普通字段 33
// private String desc;
//online属性在表中没有,但是我们有需要这个属性进行展示,所以使用TableField注解, 35
// 去掉这个字段,不让他作为查询字段。
@TableField(exist = false)
private Integer online; //用户在线或不在线
}
可以看到查询结果中不包含该字段
1.6 小结 35
这一章节,我们讲解了MybatisPlus的映射规则,以及如果通过注解配置来改变这种映射规则。
2. 条件构造器 36
2.1 条件构造器介绍
之前我们进行的MybatisPlus的操作,没有涉及到条件查询,实际上在开发需求中条件查询是非常普遍的。接下来我们就来讲解如何使用MybatisPlus完成条件查询。
首先,想要使用MybatisPlus完成条件查询,基于面向对象的思想,万物皆对象,那么查询条件也需要使用对象来完成封装。我们先看一下,在MybatisPlus中,和条件有关的类有哪些,他们之间有什么关系,理清楚了这个,我们在传递条件对象的时候,就很清晰了。
2.1.1 Wrapper
抽象类,条件类的顶层,提供了一些获取和判断相关的方法
2.1.2 AbstractWrapper
抽象类,Wrapper的子类,提供了所有的条件相关方法
2.1.3 AbstractLambdaWrapper
抽象类,AbstractWrapper的子类,确定字段参数为方法引用类型
2.1.4 QueryWrapper
类,AbstractWrapper的子类,如果我们需要传递String类型的字段信息,创建该对象
2.1.5 LambdaQueryWrapper
类,AbstractLambdaWrapper的子类,如果我们需要传递方法引用方式的字段信息,创建该对象
该图为以上各类的关系,我们在编写代码的时候,只需要关注QueryWrapper和LambdaQueryWrapper
2.2 等值查询 37
2.2.1 eq 单条件 37-40
使用QueryWrapper对象,构建查询条件
QueryTest
package com.powernode;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.powernode.domain.User;
import com.powernode.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
//条件查询 37
@SpringBootTest
public class QueryTest {
@Autowired
private UserMapper userMapper;
//等值查询eq 37
@Test
void eq(){
//1.创建条件查询对象
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//2.设置查询条件,指定查询的字段和匹配的值
queryWrapper.eq("name","Jack");
//3.进行条件查询
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
}
测试效果
我们思考如果每次都是自己进行字段名称的编写,有可能会出现名称写错的情况,怎么避免这种情况呢,我们可以使用LambdaQueryWrapper对象,在构建字段时,使用方法引用的方式来选择字段,这样做可以避免字段拼写错误出现问题。
代码如下:
QueryTest
//LambdaQueryWrapper的等值查询 38
@Test
void eq2(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName,"Jack");
User user = userMapper.selectOne(lambdaQueryWrapper);
System.out.println(user);
}
还要考虑一种情况,我们构建的条件是从哪里来的?应该是从客户端通过请求发送过来的,由服务端接收的。在网站中一般都会有多个条件入口,用户可以选择一个或多个条件进行查询,那这个时候在请求时,我们不能确定所有的条件都是有值的,部分条件可能用户没有传值,那该条件就为null。
比如在电商网站中,可以选择多个查询条件。
那为null的条件,我们是不需要进行查询条件拼接的,否则就会出现如下情况,将为null的条件进行拼接,筛选后无法查询出结果
QueryTest
//当查询条件为null时 39
@Test
void isNull(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName,null);
User user = userMapper.selectOne(lambdaQueryWrapper);
System.out.println(user);
}
当然我们要解决这个问题,可以先判断是否为空,根据判断结果选择是否拼接该字段,这个功能其实不需要我们写,由MybatisPlus的方法已经提供好了。
QueryTest
//优化当查询条件为null时 40
@Test
void isNull2(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
String name = null;
//name != null是空时将不作为查询条件 40
lambdaQueryWrapper.eq(name != null,User::getName,name);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
2.2.2 allEq 多条件 41
先演示一下如何通过多个eq,构建多条件查询
QueryTest
//多条件查询 41
@Test
void allEq1(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName,"Tom");
lambdaQueryWrapper.eq(User::getAge,28);
User user = userMapper.selectOne(lambdaQueryWrapper);
System.out.println(user);
}
如果此时有多个条件需要同时判断,我们可以将这多个条件放入到Map集合中,更加的方便
QueryTest
//多条件查询2 41
//一次通过map封装多个查询条件
@Test
void allEq2(){
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("name","Tom");
hashMap.put("age",28);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.allEq(hashMap,false);//为true或者false,就是判断是否作为查询字段
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
allEq(Map<R, V> params, boolean null2IsNull)
参数params:表示传递的Map集合
参数null2IsNull:表示对于为null的条件是否判断isNull
2.2.3 ne 不等查询 43
//不等查询 43
@Test
void ne(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.ne(User::getName,"Tom");//名字不是tom的
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3 范围查询 44
2.3.1 gt 大于
//范围查询
//大于
@Test
void gt(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
Integer age = 18;
lambdaQueryWrapper.gt(User::getAge,age);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3.2 ge 大于等于 45
//大于等于 45
@Test
void ge(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
Integer age = 18;
lambdaQueryWrapper.ge(User::getAge,age);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3.3 lt 小于 46
//小于 46
@Test
void lt(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
Integer age = 30;
lambdaQueryWrapper.lt(User::getAge,age);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3.4 le 小于等于 47
//小于等于 47
@Test
void le(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
Integer age = 30;
lambdaQueryWrapper.le(User::getAge,age);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3.5 between 48
//范围查询
//在区间内 48
@Test
void between(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.between(User::getAge,18,30);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.3.6 notBetween 49
//不在区间范围 49
@Test
void notBetween(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notBetween(User::getAge,18,30);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.4 模糊查询 50
2.4.1 like 匹配的模糊查询 50
//模糊查询 50
//like 模糊查询
@Test
void like(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(User::getName,"J");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.4.2 notLike 不匹配的模糊查询 51
//不匹配的模糊查询 51
@Test
void notLike(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notLike(User::getName,"J");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.4.3 likeLeft 左模糊匹配 52
//左模糊匹配 52
//本方法的意思是,它左边是啥都行,最有表必须是e
@Test
void likeLeft(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeLeft(User::getName,"e");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.4.4 likeRight 右模糊匹配 53
//右模糊匹配 53
@Test
void likeRight(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.likeRight(User::getName,"J");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.5 判空查询 54
2.5.1 isNull 54
如果为空就获取,否则不获取
//判空查询 54
@Test
void isNull3(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.isNull(User::getName);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
因为我们数据库中的name字段没有为空的,所以获取为0
2.5.2 isNotNull 54
如果为空就不获取,否则获取
//如果为空就不获取,否则获取 54
@Test
void isNotNull(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.isNotNull(User::getName);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.6 包含查询 55
2.6.1 in
//包含查询 55
//字段=值 or 字段=值 -> in 55
@Test
void in(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
ArrayList<Integer> arrayList = new ArrayList<>();
Collections.addAll(arrayList,18,20,22);
lambdaQueryWrapper.in(User::getAge,arrayList);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.6.2 notIn 56
//字段!=值 and 字段!=值 -> notIn 56
@Test
void notIn(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
ArrayList<Integer> arrayList = new ArrayList<>();
Collections.addAll(arrayList,18,20,22);
lambdaQueryWrapper.notIn(User::getAge,arrayList);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.6.3 inSql 57
//包含查询
//inSql支持sql语句 58
@Test
void inSql(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge,"18,20,22");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
@Test
void inSql2(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.inSql(User::getAge,"select age from powershop_user where age > 20");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
2.6.4 notInSql 58
@Test
void notInSql(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge,"18,20,22");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
@Test
void notInSql2(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.notInSql(User::getAge,"select age from powershop_user where age > 20");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
2.7 分组查询 60
2.7.1 groupBy
//分组查询 60
@Test
void groupBy(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//分组字段
queryWrapper.groupBy("age");
//查询字段
queryWrapper.select("age,count(*) as field_count");
List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
System.out.println(maps);
}
拼接的SQL如下
2.8 聚合查询 61
2.8.1 having
//聚合查询 61
@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如下
2.9 排序查询 62
2.9.1 orderByAsc 升序
//排序查询 62
//升序
@Test
void orderByAsc(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(User::getAge,User::getId);//先按照年龄排序,如果年龄一样再按照id排序
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.9.2 orderByDesc 降序 63
//降序
@Test
void orderByDesc(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByDesc(User::getAge,User::getId);//先按照年龄排序,如果年龄一样再按照id排序
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.9.3 orderBy 自定义排序方式 64
//自定义排序降序 64
@Test
void orderBy(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//设置排序字段和排序的方式 参数1:如果排序字段的值为null的时候,是否还要作为排序字段参与排序 参数2:是否是升序排序 参数3:排序字段
//线按照年龄升序,年龄一样按照id降序 64
lambdaQueryWrapper.orderBy(true,true,User::getAge);
lambdaQueryWrapper.orderBy(true,false,User::getId);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.10 func查询 65
可以根据不同的情况来选择拼接不同的查询条件
2.10.1 func
//func查询 65
@Test
void func(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//可能会根据不同的情况来选择拼接不同的查询条件
lambdaQueryWrapper.func(userLambdaQueryWrapper -> {
if (false){
userLambdaQueryWrapper.eq(User::getId,1);
}else {
userLambdaQueryWrapper.ne(User::getId,1);
}
});
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.11 逻辑查询 66
2.11.1 and 66
// 逻辑查询 66
@Test
void and(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//年龄大于22小于30
lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30); //and(条件)
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
and也可以进行嵌套 67
//and的嵌套操作 67
@Test
void and2(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getName,"wang")
.and(i -> i.gt(User::getAge,26).or().lt(User::getAge,22));
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.11.2 or 68
@Test
void or(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.lt(User::getAge,20).or().gt(User::getAge,23); //age < 20 || age > 23
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
OR嵌套 69
//or的嵌套 69
@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如下
2.11.3 nested 70
直接将条件拼接在where后面
//70
@Test
void nested(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//名字是tom且年龄不是22
lambdaQueryWrapper.nested(i -> i.eq(User::getName,"Tom").ne(User::getAge,22));
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.12 自定义条件查询 71
可以将我们所写的条件直接拼接在where后面
2.12.1 apply
//自定义条件查询 71
@Test
void apply(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.apply("id = 1");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.13 last查询 72
将传递一个字符串,可以将字符串拼接在sql语句的最后面
2.13.1 last 72
//将传递一个字符串,可以将字符串拼接在sql语句的最后面 72
@Test
void last(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.last("limit 0,2");
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.14 exists查询 73
2.14.1 exists 73
//exists会根据子查询的结果来判断主查询是否保留 73
@Test
void exists(){
//1.创建QueryWrapper对象
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//2.构建查询条件
//age没有等于188的,主查询数据不会保留
lambdaQueryWrapper.exists("select id from powershop_user where age = 188");
//3.查询
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.14.2 notExists 74
//与exists正好相反 74
@Test
void notExists(){
//1.创建QueryWrapper对象
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//2.构建查询条件
lambdaQueryWrapper.notExists("select id from powershop_user where age = 18");
//3.查询
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.15 字段查询 75
2.15.1 select 75
//查询字段 75
@Test
void select(){
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//查询时只有这两个字段会被查询出来
lambdaQueryWrapper.select(User::getId,User::getName);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
System.out.println(users);
}
拼接的SQL如下
2.16 小结 75
本章节讲解了条件查询中的各种查询操作,我们可以通过面向对象的形式,直接调用方法来完成mysql中的条件查询
好博客就要一起分享哦!分享海报
此处可发布评论
评论(0)展开评论
展开评论