版权声明:本文为博主原创文章,未经博主允许不得转载。
本文链接
创建条件构造器的三种方法
注意:条件构造器中条件中的参数为数据库的列名!!!
案例://查询名字中包含’雨’ 且 年龄小于40的用户, sql为: name like ‘%雨%’ and age < 40
- 创建QuaryWrapper对象
//实现类调用相应方法,传入创建的条件构造器对象即可
QueryWrapper queryWrapper = new QueryWrapper();
queryWrapper.like("name", "雨");
queryWrapper.lt("age", 40);
userMapper.selectList(queryWrapper).forEach(System.out::println);
- Wrappers.query()
//另一种要赋给对象变量的方式创建,注意泛型的位置
QueryWrapper<User> queryWrapper =
Wrappers.<User>query().like("name", "雨").lt("age", 40);
userMapper.selectList(queryWrapper).forEach(System.out::println);
- 直接链式调用
//这种方式查询时不用具体调用实现类的查询方法,直接调用list()即可遍历
new QueryChainWrapper<>(userMapper).
like("name", "雨").lt("age", 40)
.list().forEach(System.out::println);
一些案例
- isNotNull()
/**
* 名字中包含'雨'并且年龄大于等于20且小于等于40并且email不为空
* name like '%雨%' and age between 20 and 40 and email is not null
*/
@Test
public void selectByWrapper2() {
new QueryChainWrapper<>(userMapper)
.like("name", "雨").between("age", 20, 40).isNotNull("email")
.list().forEach(System.out::println);
}
- 排序
/**
* 名字为王姓或者年龄大于等于25,按照年龄降序排列,年龄相同,按照id升序排列
* name like '王%' or age >= 25 order by age desc,id asc
*/
@Test
public void selectByWrapper3() {
new QueryChainWrapper<>(userMapper)
.likeRight("name", "王")
.or()
.ge("age",25)
.orderByDesc("age")
.orderByAsc("id")
.list().forEach(System.out::println);
}
- apply()–> 可能有sql注入风险, inSql()
/**
* 创建日期为2019年2月14日并且直属上级姓为王姓
* date_format(create_time,'%Y-%m-%d') and manager_id in(select id from mp_user where name like '王%')
*/
@Test
public void selectByWrapper4() {
new QueryChainWrapper<>(userMapper)
/*
数据库函数
注意:apply()单参数版本存在SQL注入风险
.apply("date_format(create_time,'%Y-%m-%d')=2019-02-14 or true or true"),
请使用apply()多参数的带占位符的版本,可以避免SQL注入
*/
.apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14")
//子查询
.inSql("manager_id", "select id from mp_user where name like '王%'")
.list().forEach(System.out::println);
}
- and(),or()
/**
* 名字为王姓并且(并且年龄小于40或者邮箱不为空)
* name like '王%' and (age < 40 or email is not null)
*/
@Test
public void selectByWrapper5() {
new QueryChainWrapper<>(userMapper)
.likeRight("name", "王")
//Lambda表达式
.and(qw -> qw.lt("age", 40).or().isNotNull("email"))
.list().forEach(System.out::println);
}
- lambda
/**
* 名字为王姓或者(年龄小于40并且年龄大于20并且邮箱不为空)
* name like '王%' or (age<40 and age>20 and email is not null)
*/
@Test
public void selectByWrapper6() {
new QueryChainWrapper<>(userMapper)
.likeRight("name", "王")
.or(qw -> qw.lt("age", 40).gt("age", 20).isNotNull("email"))
.list().forEach(System.out::println);
}
- nested(),list()
/**
* (年龄小于40或者邮箱不为空)并且名字为王姓
* (age<40 or email is not null) and name like '王%'
*/
@Test
public void selectByWrapper7() {
new QueryChainWrapper<>(userMapper)
.nested(qw -> qw.lt("age", 40).or().isNotNull("email"))
.likeRight("name", "王")
.list().forEach(System.out::println);
}
- in()
/**
* 年龄为30,31,34,35
* age in(30,31,34,35)
*/
@Test
public void selectByWrapper8() {
new QueryChainWrapper<>(userMapper)
.in("age", 30, 31, 34, 35)
.list().forEach(System.out::println);
}
- last(),–> 有sql注入风险
/**
* 只返回满足条件的一条语句
* limit 1
*/
@Test
public void selectByWrapper9() {
new QueryChainWrapper<>(userMapper)
.in("age", 30, 31, 34, 35)
//注意:此方式存在SQL注入风险,谨慎使用!!!
.last("limit 1")
.list().forEach(System.out::println);
}
- select()
//!!!注意:如果select()中的列名和尸体了id属性名不同
// 可以:queryWrapper.select("id", "name as relname")
/**
* 只查询id和姓名
* 罗列要查询的列名
*/
@Test
public void selectByWrapper10() {
QueryWrapper<User> queryWrapper = Wrappers.query();
queryWrapper.select("id", "name").like("name", "雨").lt("age", 40);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
- select(User.class,lambda)
/**
* 查询除create_time和manager_id以外的列
*/
@Test
public void selectByWrapper11() {
QueryWrapper<User> queryWrapper = Wrappers.query();
queryWrapper.select(User.class,
info -> !info.getColumn().equals("create_time")
&& !info.getColumn().equals("manager_id"))
.like("name", "雨").lt("age", 40);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
- StringUtils.isNotEmpty(),条件的第一个参数是condition
//模拟控制器方法
private void condition(String name, String email) {
QueryWrapper<User> queryWrapper = Wrappers.query();
//判断参数
/* if (StringUtils.isNotEmpty(name)) {
queryWrapper.like("name", name);
}
if (StringUtils.isNotEmpty(email)) {
queryWrapper.eq("email", email);
}*/
//条件的第一个参数condition,表示当不满足时,该条件不起作用
queryWrapper
.like(StringUtils.isNotEmpty(name), "name", name)
.eq(StringUtils.isNotEmpty(email), "email", email);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
- new QueryWrapper<>(user)
//创建条件构造器时传入实体对象
@Test
public void selectByWrapperEntity() {
//构建实体条件
User user = new User();
//默认规则是相等,可以修改实体属性,添加注解来修改默认规则
user.setName("雨");
user.setAge(40);
//条件构造器传入实体对象
QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
//queryWrapper.eq("manager_id", 1088248166370832385L);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
- allEq的用法(的过滤条件)
/**
* allEq的用法
*/
@Test
public void selectByWrapperAllEq() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
Map<String, Object> map = new HashMap<>();
map.put("name", "王天风");
map.put("age", 25);
//false表示如果参数值为null,则自动忽略该参数
//queryWrapper.allEq(map, false);
//过滤指定条件
queryWrapper.allEq((k, v) -> !k.equals("name"), map);
userMapper.selectList(queryWrapper).forEach(System.out::println);
}
- selectMaps()
/**
* selectMaps的用法
* 返回map集合的方法,此方式适用于查询少数列值的情况,无需封装实体(因为很多字段都是null)
*/
@Test
public void selectByWrapperMaps() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("name", "age").like("name", "雨").lt("age", 40);
userMapper.selectMaps(queryWrapper).forEach(System.out::println);
}
- groupBy().having()
/**
* 按照直属上级分组,查询每组的平均年龄,最大年龄,最小年龄
* 并且只取年龄总和<500的组
* select avg(age) avg_age,min(age) min_age,max(age) max_age from mp_user
* group by manager_id having sum(age)<500
*/
@Test
public void selectByWrapperMaps2() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper
.select("avg(age) avg_age", "min(age) min_age", "max(age) max_age")
.groupBy("manager_id")
.having("sum(age)<{0}", 500);
userMapper.selectMaps(queryWrapper).forEach(System.out::println);
}
- selectObjs()
/**
* selectObjs()
* 注意: 此方法值返回查询结果第一列的值
*/
@Test
public void selectByWrapperObjs() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.select("name", "age").like("name", "雨").lt("age", 40);
userMapper.selectObjs(queryWrapper).forEach(System.out::println);
}
- selectCount()
/**
* selectCount()
* 查询总记录数
* select count(1) from mp_user
*
* 注意:此方法不要使用查询指定列,因为默认会使用select count(1) from...
*/
@Test
public void selectByWrapperCount() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨").lt("age", 40);
Integer count = userMapper.selectCount(queryWrapper);
System.out.println(count);
}
- selectOne()
/**
* selectOne()
* 查询一个对象
*
* 注意:此方法只能返回一条记录或者没有没有记录,如果查询出多条记录,则报错
*/
@Test
public void selectByWrapperOne() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "刘红雨").lt("age", 40);
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
lambda的条件构造器的四种创建方法
LambdaQueryWrapper<User> lambdaQueryWrapper = new QueryWrapper<User>().lambda();
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
new LambdaQueryChainWrapper<>(userMapper).like(User::getName, "雨").list().foreach(..);
- lambda条件构造器
/**
* lambda条件构造器
* 作用:防误写
*/
@Test
public void selectByWrapperLambda() {
//LambdaQueryWrapper<User> lambdaQueryWrapper = new QueryWrapper<User>().lambda();
LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
lambdaQueryWrapper.like(User::getName, "雨").lt(User::getAge, 40);
List<User> users = userMapper.selectList(lambdaQueryWrapper);
users.forEach(System.out::println);
System.out.println(">>>>>>>>>>>>>>>>>>>>>>>");
//链式调用
new LambdaQueryChainWrapper<>(userMapper)
.like(User::getName, "雨")
.lt(User::getAge, 40)
.list().forEach(System.out::println);
}
likeRight(User::getName, "王")
调用getName方法,防止写字符串写错
/**
* 名字为王姓并且(并且年龄小于40或者邮箱不为空)
* name like '王%' and (age < 40 or email is not null)
*/
@Test
public void selectByWrapperLambda2() {
new LambdaQueryChainWrapper<>(userMapper)
.likeRight(User::getName, "王")
.and(qw -> qw.lt(User::getAge, 40).or().isNotNull(User::getEmail))
.list().forEach(System.out::println);
}
自定义Mapper(多表,分页)
- 测试自定义mapper方法
仿照自带方法的定义形参列表,发现传入Wrapper对象即可
//自定义方法
//@Select("select * from mp_user ${ew.customSqlSegment}")
List<User> selectAllUsers(@Param(Constants.WRAPPER) Wrapper<User> queryWrapper);
xml文件,传入ew参数,调用它的成员即可
<!--有${ew.customSqlSegment}就相当于此查询拼接了wrapper条件过滤-->
<select id="selectAllUsers" resultType="user">
select * from mp_user ${ew.customSqlSegment}
</select>
调用自定义的mapper方法即可
/**
* 测试自定义mapper方法
*/
@Test
public void selectAllUsers() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨").lt("age", 40);
List<User> users = userMapper.selectAllUsers(queryWrapper);
users.forEach(System.out::println);
}
- 自定义分页方法
mapper接口的分页方法
//自定义分页方法(实现多表联查+多条件组合查询并且分页)
IPage<User> selectUsersByPage(
Page<User> age,@Param(Constants.WRAPPER) Wrapper<User> queryWrapper);
xml中的方法
<select id="selectUsersByPage" resultType="user">
select * from mp_user ${ew.customSqlSegment}
</select>
测试方法
/**
* 测试分页方法
* selectPage
* <p>
* 注意:
* 默认情况下分页方法会先查询符合条件的记录总数,然后再执行分页方法,
* 有些情况下,不需要查询符合条件的记录总数,则可以设置:
*
* !!! Page对象构建时,传入第三个参数为false,表示不查询总记录数
*/
@Test
public void selectPage() {
Page<User> p = new Page<>(1, 2);
//Page<User> p = new Page<>(1, 2, false);
QueryWrapper<User> qw = new QueryWrapper<>();
qw.lt("age", 40);
// 内置分页方法(只能单表查询)
// IPage<User> page = userMapper.selectPage(p, qw);
// 调用自定义分页方法(可以构建多表查询)
IPage<User> page = userMapper.selectUsersByPage(p, qw);
System.out.println("当前页: " + page.getCurrent());
System.out.println("每页显示多少条记录: " + page.getSize());
System.out.println("总页数: " + page.getPages());
System.out.println("总记录数:" + page.getTotal());
page.getRecords().forEach(System.out::println);
}
- 分页测试二
/**
* 测试分页方法
* selectMapsPage
*/
@Test
public void selectMapsPage() {
Page<User> p = new Page<>(1, 2);
QueryWrapper<User> qw = new QueryWrapper<>();
qw.select("name", "age").lt("age", 40);
IPage<Map<String, Object>> page = userMapper.selectMapsPage(p, qw);
System.out.println("当前页: " + page.getCurrent());
System.out.println("每页显示多少条记录: " + page.getSize());
System.out.println("总页数: " + page.getPages());
System.out.println("总记录数:" + page.getTotal());
page.getRecords().forEach(System.out::println);
}
改&删
- 根据id更新,注意虽然是根据id更新,但参数为entity
/**
* 测试根据id更新的方法
*/
@Test
public void updateById() {
User user = new User();
user.setId(1183555543882186753L);
user.setName("刘明强强");
user.setEmail("lmq@baomidou.com");
int rows = userMapper.updateById(user);
System.out.println("影响的记录数: " + rows);
}
update查询构造器创建方法
-
UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
-
UpdateWrapper<User> userUpdateWrapper = Wrappers.update();
-
new UpdateChainWrapper<>(userMapper).eq("age", 32).update(user);
-
new LambdaUpdateChainWrapper<>(userMapper).eq(User::getName, "刘明强").set(User::getName, "刘明弱").update()
- 以条件构造器作为参数的更新方法
/**
* 测试以条件构造器作为参数的更新方法
*/
@Test
public void updateByWrapper() {
//更新的条件过滤器
//UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
/* UpdateWrapper<User> userUpdateWrapper = Wrappers.update();
!!! 注意:Wrapper后边的方法里是查询的过滤条件,先找出来在改,相当于sql里的where
userUpdateWrapper.eq("name", "刘明强").eq("age", 31);
!!! 注意:User对象才是要更新的数据,相当于sql里的set
User user = new User();
user.setName("刘明弱");
user.setAge(32);
int rows = userMapper.update(user, userUpdateWrapper);
System.out.println("影响的记录数: " + rows);*/
//链式调用
User user = new User();
user.setName("刘明强");
user.setAge(31);
boolean update = new UpdateChainWrapper<>(userMapper)
.eq("name", "刘明弱").eq("age", 32).update(user);
//返回boolean类型,表示是否执行成功
System.out.println(update);
}
- Lambda更新 + set更新方式,调用的是无参update()
//Lambda更新 + set更新方式
@Test
public void updateByWrapperLambda() {
boolean update = new LambdaUpdateChainWrapper<>(userMapper)
.eq(User::getName, "刘明强").eq(User::getAge, 31)
.set(User::getName, "刘明弱").set(User::getAge, 32)
.update();
System.out.println(update);
}
delete
- 根据id删除记录
//根据id删除记录
@Test
public void deleteById() {
int rows = userMapper.deleteById(1183555543882186753L);
System.out.println(rows);
}
- map里的相当于条件
//根据map删除记录
@Test
public void deleteByMap() {
Map<String, Object> map = new HashMap<>();
//map.put("name", "刘红雨");
map.put("age", 32);
int rows = userMapper.deleteByMap(map);
System.out.println(rows);
}
- 批量删除(例如表格)
//根据多个id删除记录
@Test
public void deleteBatchIds() {
int rows = userMapper.deleteBatchIds(
Arrays.asList(1094592041087729666L, 1183555543882186753L));
System.out.println(rows);
}
- 条件构造器的删除
//条件构造器的删除
@Test
public void deleteByWrapper() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "雨").lt("age", 40);
int rows = userMapper.delete(queryWrapper);
System.out.println(rows);
}