---mp实用案例---

最新推荐文章于 2023-03-21 11:37:07 发布

xxxoot

最新推荐文章于 2023-03-21 11:37:07 发布

阅读量380

点赞数

分类专栏： MybatisPlus

本文链接：https://blog.csdn.net/qq_44061725/article/details/103974156

版权

MybatisPlus 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

版权声明：本文为博主原创文章，未经博主允许不得转载。
本文链接

创建条件构造器的三种方法

注意:条件构造器中条件中的参数为数据库的列名!!!

案例://查询名字中包含’雨’ 且年龄小于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);
    }

xxxoot

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
---mp实用案例---

版权声明：本文为博主原创文章，未经博主允许不得转载。创建条件构造器的三种方法注意:条件构造器中条件中的参数为数据库的列名!!!案例://查询名字中包含’雨’ 且年龄小于40的用户, sql为: name like ‘%雨%’ and age < 40创建QuaryWrapper对象//实现类调用相应方法,传入创建的条件构造器对象即可QueryWrapper quer...
复制链接

扫一扫

专栏目录