（Mybatis笔记）Mybatis-Plus——封装接口IService使用（二）

最新推荐文章于 2024-03-01 16:01:40 发布

电竞丶小松哥

最新推荐文章于 2024-03-01 16:01:40 发布

阅读量6.7k

点赞数 7

分类专栏： Mybatis笔记文章标签： SpringBoot mybatis-plus mysql IService navicat

ZSAndroid

本文链接：https://blog.csdn.net/qq_39038178/article/details/120668991

版权

Mybatis笔记专栏收录该内容

6 篇文章 6 订阅

订阅专栏

源码地址：https://github.com/GuiZhouAndroid/mybatisDemo

1.前言

接第一篇后，继续演示MP功能演示，上一章链接传送门：

（Mybatis笔记）Mybatis-Plus——封装接口IService使用（一）

CSDN链接：https://blog.csdn.net/qq_39038178/article/details/120612802

2.查询数据（Select）

2.1 查询单条数据

（1）通过自增ID值，查询用户信息，新增接口如下：

    /** 通过自增ID值，查询用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectUserInfoById
    @RequestMapping("/selectUserInfoById")
    public UserLoginBean selectUserInfoById(){
        //通过主键ID值，查询对应用户名和密码，返回查询当前用户的实体对象
        return userLoginService.getById(1);
    }

浏览器访问接口后：

（2）通过 QueryWrapper，查询一条用户信息。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")，新增接口如下：

    /** 通过 QueryWrapper，查询一条用户信息。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1") */
    //浏览器访问 http://localhost:8085/user-login-bean/selectUserInfoByWrapper
    @RequestMapping("/selectUserInfoByWrapper")
    public UserLoginBean selectUserInfoByWrapper(){
        //创建查询条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造查询条件
        queryWrapper
                .select("ul_id","ul_username","ul_password") // SELECT ul_id,ul_username,ul_password FROM t_user_login
                .eq("ul_username","1批量更新用户名root")
                .eq("ul_password","1批量更新密码root") // WHERE (ul_username = '1批量更新用户名root' AND ul_password = '1批量更新密码root')
                //限制查询一条数据，避免数据库中有同时重复用户名+密码，我对用户名进行唯一约束的因此不会查询出多条数据就不会抛出异常
                .last("LIMIT 1"); //LIMIT 1
        //返回查询当前用户的实体对象
        return userLoginService.getOne(queryWrapper);
    }

    /** 通过 QueryWrapper，查询一条用户信息。有多个结果集 result 是否抛出异常 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectUserInfoByWrapperIfThrow
    @RequestMapping("/selectUserInfoByWrapperIfThrow")
    public UserLoginBean selectUserInfoByWrapperIfThrow(){
        //创建查询条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造查询条件
        queryWrapper
                .select("ul_id","ul_username","ul_password") // SELECT ul_id,ul_username,ul_password FROM t_user_login
                .eq("ul_username","1批量更新用户名root")
                .eq("ul_password","1批量更新密码root")// WHERE (ul_password = '1批量更新密码root')
                .last("LIMIT 1"); //LIMIT 1
        //返回查询当前用户的实体对象
        return userLoginService.getOne(queryWrapper,false);
    }

浏览器访问接口后：

（3）通过QueryWrapper，查询一条用户信息，存放至map集合，新增接口如下：

    /** 通过QueryWrapper，查询一条用户信息，存放至map集合 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectUserInfoByWrapperBackMap
    @RequestMapping("/selectUserInfoByWrapperBackMap")
    public Map<String, Object> selectUserInfoByWrapperBackMap(){
        //创建查询条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造查询条件
        queryWrapper
                .select("ul_id","ul_username","ul_password") // SELECT ul_id,ul_username,ul_password FROM t_user_login
                .eq("ul_username","2批量更新用户名root")
                .eq("ul_password","2批量更新密码root")// WHERE (ul_password = '2批量更新密码root')
                .last("LIMIT 1"); //LIMIT 1
        //当前查询用户信息返回存放map集合
        return userLoginService.getMap(queryWrapper);
    }

浏览器访问接口后：

2.2 查询数据List

（1）查询全部用户信息，新增接口如下：

    /** 查询全部用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectAllUserInfo
    @RequestMapping("/selectAllUserInfo")
    public List<UserLoginBean> selectAllUserInfo(){
        //用户信息存放到List集合
        return userLoginService.list();
    }

浏览器访问接口后：（Text数据太长，这里我postman测试）

（2）通过QueryWrapper条件，列表查询用户信息，新增接口如下：

    /** 通过QueryWrapper条件，列表查询用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListUserInfoByWrapper
    @RequestMapping("/selectListUserInfoByWrapper")
    public List<UserLoginBean> selectListUserInfoByWrapper(){
        //创建查询条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .gt("ul_id",1); //查询自增ID值大于1的用户信息
        //用户信息存放到List集合
        return userLoginService.list(queryWrapper);
    }

浏览器访问接口后：

（3）通过主键自增ID列表，批量查询用户信息，新增接口如下：

    /** 通过主键自增ID列表，批量查询用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListUserInfoByListIds
    @RequestMapping("/selectListUserInfoByListIds")
    public List<UserLoginBean> selectListUserInfoByListIds(){
        //创建List集合，装载批量主键自增ID数据
        List<Integer> loginBeans = new ArrayList<>();
        //ID的List列表放入1，即查询自增ID为1的用户全部信息
        loginBeans.add(1);
        //用户信息存放到List集合
        return userLoginService.listByIds(loginBeans);
    }

浏览器访问接口后：

***改动用户表，添加两条信息，密码全设置为root***

（4）通过map集合中column值，批量列表查询用户信息，新增接口如下：

    /** 通过Map集合中column值，批量列表查询用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListUserInfoByMapColumn
    @RequestMapping("/selectListUserInfoByMapColumn")
    public List<UserLoginBean> selectListUserInfoByMapColumn(){
        //创建Map集合，存放Column数据
        HashMap<String,Object> hashMap = new HashMap<>();
        //构造参数
        hashMap.put("ul_password","root");
        //字段名ul_password对应密码为"root"的全部用户信息存放到List集合
        return userLoginService.listByMap(hashMap);
    }

浏览器访问接口后：

（5）查询全部用户信息列表，放入Map,返回到List，新增接口如下：

    /** 查询全部用户信息列表，放入Map,返回到List */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListAndMapAllUserInfo
    @RequestMapping("/selectListAndMapAllUserInfo")
    public List<Map<String, Object>> selectListAndMapAllUserInfo(){
        //查询全部用户信息，返回到List集合
        return userLoginService.listMaps();
    }

浏览器访问接口后：（区别：返回List集合，k值是实例类属性名称，返回Map集合，k值对应MySQL用户表的字段名称，带有下划线"_"，例如："ulId"、"ul_id"）

（6）通过QueryWrapper查询用户信息列表，放入Map,返回到List，新增接口如下：

    /** 通过QueryWrapper查询用户信息列表，放入Map,返回到List */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListAndMapUserInfoByWrapper
    @RequestMapping("/selectListAndMapUserInfoByWrapper")
    public List<Map<String, Object>> selectListAndMapUserInfoByWrapper(){
        //创建查询条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .select("ul_id","ul_username","ul_password")
                //.ge("ul_id",2)//大于等于2 ul_id >= 2
                //.le("ul_id",6)//小于等于6 ul_id <= 6
                //.or()
                .like("ul_password","o");//模糊查询 ul_password LIKE '%o%'
        //用户信息，返回到List集合
        return userLoginService.listMaps(queryWrapper);
    }

浏览器访问接口后：

（7）返回全部记录，但只返回第一个字段的值，新增接口如下：

    /** 查询全部记录 */
    //浏览器访问 http://localhost:8085/user-login-bean/selectListUserInfoByObjs
    @RequestMapping("/selectListUserInfoByObjs")
    public List<Object> selectListUserInfoByObjs(){
        return userLoginService.listObjs();
    }

浏览器访问接口后：只返回第一个字段的值

说明：Function<? super Object, V> ，本人不知道怎么用，就不介绍这个了

2.3 分页查询Page

（1）无条件分页查询【IPage(实体对象)】第1页数据（每页2条记录），新增接口如下：

    /** 无条件分页查询【IPage(实体对象)】第1页数据（每页2条记录）*/
    //浏览器访问 http://localhost:8085/user-login-bean/unconditionalPage
    @RequestMapping("/unconditionalPage")
    public IPage<UserLoginBean> unconditionalPage(){
        // 1.创建IPage实例，初始化分页查询参数：第1页，显示2条数据
        IPage<UserLoginBean> iPage = new Page<>(1,2);
        /** 获取分页数据 */
        System.out.println(iPage.getCurrent()); // 获取当前页
        System.out.println(iPage.getTotal()); // 获取总记录数
        System.out.println(iPage.getSize()); // 获取每页的条数 默认10
        System.out.println(iPage.getRecords()); // 获取每页数据的集合
        System.out.println(iPage.getPages()); // 获取总页数
        /** IPage没有hasNext()、hasPrevious()，Page有hasNext()、hasPrevious() */
        //System.out.println(iPage.hasNext()); // 是否存在下一页
        //System.out.println(iPage.hasPrevious()); // 是否存在上一页
        //2.开始执行无条件分页查询
        return userLoginService.page(iPage);
        /** 以下是无条件分页查询代码优化版，注释上面代码，去除以下代码即可 */
        //匿名对象方式设置分页参数，开始执行无条件分页查询
        //return userLoginService.page(new Page<>(1,2));
    }

浏览器访问接口后：

重点说明：因为查询总条数有4条用户数据，而设置每页显示2条用户数据，所以LIMIT会自动依据“Page<>(1,2);”的值，动态查询返回相应用户数据，从而实现分页查询功能。

（2）有条件分页查询第1页数据（每页2条记录），新增接口如下：

    /** 有条件分页查询第1页数据（每页2条记录）*/
    //浏览器访问 http://localhost:8085/user-login-bean/conditionalPage
    @RequestMapping("/conditionalPage")
    public IPage<UserLoginBean> conditionalPage(){
        //1.创建IPage实例，初始化分页查询参数：第1页，显示2条数据
        IPage<UserLoginBean> userLoginBeanPage = new Page<>(1,2);
        //构造分页查询QueryWrapper条件（链式调用 lambda 式、QueryWrapper实例，两种方式均可以构造分页查询条件）
        /** 创建条件对象方式一：new QueryWrapper */
        //QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造分页查询条件
        //queryWrapper.select("ul_id","ul_username","ul_password")
                //.ge("ul_id",1)//大于等于2 ul_id >= 1
                //.le("ul_id",6);//小于等于6 ul_id <= 6
        /** 创建条件对象方式二：new LambdaQueryWrapper */
        //2.创建Wrapper对象
        LambdaQueryWrapper<UserLoginBean> wrapper = new LambdaQueryWrapper<>();
        //构造分页查询条件
        wrapper
                .ge(UserLoginBean::getUlId,1) //大于等于2 ul_id >= 2
                .le(UserLoginBean::getUlId,6); //小于等于6 ul_id <= 6
        /** 省略获取分页数据，可选操作 */
        //System.out.println(iPage....); // 获取当前页
        //...
        //3.调用IService封装的page()，传入分页查询参数+分页查询条件--->开始执行分页查询操作，返回用户信息分页查询结果
        return userLoginService.page(userLoginBeanPage, wrapper);
    }

浏览器访问接口后：请注意：此处效果同上，实际开发中，条件可以根据业务需求设置，查询出的数据当然不会跟我一样，本人为了演示代码和效果。

不同点：查询总记录条数据时，有where条件筛选用户数据

（3）无条件Map分页查询第1页数据（每页1条记录），新增接口如下：

    /** 无条件Map分页查询第1页数据（每页1条记录）*/
    //浏览器访问 http://localhost:8085/user-login-bean/unconditionalPageMaps
    @RequestMapping("/unconditionalPageMaps")
    public IPage<Map<String,Object>> unconditionalPageMaps(){
        //1.创建IPage实例，初始化分页查询参数：第1页，显示1条数据
        IPage<Map<String,Object>> mapIPage = new Page<>(1,1);
        /** 省略获取分页数据，可选操作 */
        //System.out.println(iPage....); // 获取当前页
        //...
        //2.返回用户信息分页查询结果
        return userLoginService.pageMaps(mapIPage);
        /** 以下是无条件分页查询代码优化版，注释上面代码，去除以下代码即可 */
        //return userLoginService.pageMaps(new Page<>(1,1));
    }

浏览器访问接口后：

（4）有条件Map分页查询第1页数据（每页1条记录），新增接口如下：

    /** 有条件Map分页查询第1页数据（每页1条记录）*/
    //浏览器访问 http://localhost:8085/user-login-bean/conditionalPageMaps
    @RequestMapping("/conditionalPageMaps")
    public IPage<Map<String,Object>> conditionalPageMaps(){
        //1.创建IPage实例，初始化分页查询参数：第1页，显示1条数据
        IPage<Map<String,Object>> iPageParam = new Page<>(1,1);
        //2.创建Wrapper对象（链式调用 lambda 式、QueryWrapper实例，两种方式均可以构造分页查询条件）
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //3.构造分页查询条件
        queryWrapper.select("ul_id","ul_username","ul_password")
        .ge("ul_id",1)//大于等于2 ul_id >= 1
        .le("ul_id",6);//小于等于6 ul_id <= 6
        /** 省略获取分页数据，可选操作 */
        //System.out.println(iPage....); // 获取当前页
        //...
        //4.调用IService封装的page()，传入分页查询参数+分页查询条件--->开始执行分页查询操作，返回用户信息分页查询结果
        return userLoginService.pageMaps(iPageParam, queryWrapper);
    }

浏览器访问接口后：（有where条件）

2.4 计数Count

（1）查询全部用户信息数量，新增接口如下：

    /** 查询全部用户信息数量 */
    //浏览器访问 http://localhost:8085/user-login-bean/countUserInfo
    @RequestMapping("/countUserInfo")
    public Long countUserInfo(){
        //返回Long类型，数值为用户信息总条数
        return userLoginService.count();
    }

浏览器访问接口后：

（2）通过QueryWrapper条件，查询全部用户信息数量，新增接口如下：

    /** 通过QueryWrapper条件，查询全部用户信息数量 */
    //浏览器访问 http://localhost:8085/user-login-bean/countUserInfoByWrapper
    @RequestMapping("/countUserInfoByWrapper")
    public Long countUserInfoByWrapper(){
        //创建Wrapper条件对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造查询条件：自增ID在2——5之间有多少条用户数据
        queryWrapper.between("ul_id",2,5);//目前用户表有4条
        //返回Long类型，数值为用户信息总条数
        return userLoginService.count(queryWrapper);
    }

浏览器访问接口后：

3.总结

仅自己学习记录，如有错误，敬请谅解~，谢谢~~~

电竞丶小松哥

关注

7
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
（Mybatis笔记）Mybatis-Plus——封装接口IService使用（二）

目录1.前言2.查询数据（Select）2.1 查询单条数据2.2 查询数据List2.3 分页查询Page1.前言接第一篇后，继续演示MP功能演示，上一章链接传送门：（Mybatis笔记）Mybatis-Plus——封装接口IService使用（一） CSDN链接：https://blog.csdn.net/qq_39038178/article/details/12...
复制链接

扫一扫