Mybatis-plus

最新推荐文章于 2022-12-16 20:00:00 发布
最新推荐文章于 2022-12-16 20:00:00 发布
阅读量202 收藏 1
点赞数
分类专栏： mybatis plus 文章标签： java mybatis plus
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45988242/article/details/119982974
版权

目录

条件构造器

allEq


    @Test
    public void testAllEq() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //组装条件
        Map<String, Object> param = new HashMap<>();
        //map<key,value> key列名 , value：查询的值
        param.put("name", "张三");
        param.put("age", 22);
        param.put("status", 1);

        qw.allEq(param);
        //调用MP自己的查询方法
        //SELECT id,name,age,email,status FROM student WHERE name = ? AND age = ?
        //WHERE name = ? AND age = ? AND status = ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

    /**
     * 1) Map对象中有 key的value是null
     * 使用的是 qw.allEq(param,true);
     * 结果：WHERE name = ? AND age IS NULL
     * <p>
     * 2) Map对象中有 key的value是null
     * qw.allEq(param,false);
     * 结果：WHERE name = ?
     * <p>
     * 结论：
     * allEq(map,boolean)
     * true:处理null值，where 条件加入 字段 is null
     * false:忽略null ，不作为where 条件
     */
    @Test
    public void testAllEq2() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //组装条件
        Map<String, Object> param = new HashMap<>();
        //map<key,value> key列名 , value：查询的值
        param.put("name", "张三");
        //age 是 null
        param.put("age", null);

        //allEq第二个参数为true
        qw.allEq(param, false);

        //调用MP自己的查询方法
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

eq

 /**
     * eq使用
     * eq("列名",值)
     */
    @Test
    public void testEq() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //组成条件
        qw.eq("name", "李四");
        //WHERE name = ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("查询eq：" + stu));

    }

ne 不等于

 /**
     * ne使用
     * ne表示不等于 <>
     * <p>
     * ne("列名",值)
     */
    @Test
    public void testNe() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //组成条件
        qw.ne("name", "张三");
        // WHERE name <> ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("查询ne:" + stu));
    }

gt 大于

/**
     * gt 大于( > )
     */
    @Test
    public void testGt() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.gt("age", 30); //age > 30
        // WHERE age > ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("stu:" + stu));
    }

ge 大于等于

/**
     * ge 大于等于 （ >=）
     */
    @Test
    public void testGe() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.ge("age", 31);// >=31
        //WHERE age >= ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("student:" + stu));
    }

lt 小于

/**
     * lt 小于 ( < )
     */
    @Test
    public void testLt() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.lt("age", 32);
        // WHERE age < ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("student:" + stu));
    }

le 小于

 /**
     * le 小于 ( <= )
     */
    @Test
    public void testLe() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.le("age", 32);
        //  WHERE age <= ?
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println("student:" + stu));
    }

between

  /**
     * between ( ? and ? )
     */
    @Test
    public void testBetween() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //between("列名",开始值，结束值)
        qw.between("age", 22, 28);
        // where age >= 12 and age < 28
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

notBetween(不在范围区间内)

    /**
     * notBetween(不在范围区间内)
     */
    @Test
    public void testNotBetween() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.notBetween("age", 18, 28);
        //WHERE age NOT BETWEEN ? AND ?
        // where age < 18 or age > 28
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

like 匹配某个值

 /**
     * like 匹配某个值
     */
    @Test
    public void testLike() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.like("name", "张");
        // WHERE name LIKE %张%
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

notLike 不匹配某个值

  /**
     * notLike 不匹配某个值
     */
    @Test
    public void testNotLike() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.notLike("name", "张");
        //  WHERE name NOT LIKE ?  %张%
        List<Student> students = studentDao.selectList(qw);
        students.forEach(stu -> System.out.println(stu));
    }

likeLeft “%值”

 /**
     * likeLeft "%值"
     */
    @Test
    public void testLikeLeft() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.likeLeft("name", "张");
        //WHERE name LIKE %张
        List<Student> students = studentDao.selectList(qw);
        students.forEach(student -> System.out.println(student));
    }

likeRight “%值”

    /**
     * likeRight "%值"
     */
    @Test
    public void testLikeRight() {
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.likeRight("name", "李");
        //WHERE name LIKE 李%
        List<Student> students = studentDao.selectList(qw);
        students.forEach(student -> System.out.println(student));
    }

isNull , 判断字段是 null


    /**
     * isNull , 判断字段是 null
     */
    @Test
    public void testIsNull(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //判断email is null
        //WHERE email IS NULL
        qw.isNull("email");
        print(qw);
    }

isNotNull , 判断字段是 is not null

/**
     * isNotNull , 判断字段是 is not null
     */
    @Test
    public void testIsNotNull(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        // WHERE email IS NOT NULL
        qw.isNotNull("email");
        print(qw);
    }

in 值列表

    /**
     * in 值列表
     */
    @Test
    public void testIn(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //in(列名，多个值的列表)
        //WHERE name IN (?,?,?)
        qw.in("name","张三","李四","周丽");
        print(qw);

    }

notIn 不在值列表

  /**
     * notIn 不在值列表
     */
    @Test
    public void testNoIn(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //in(列名，多个值的列表)
        //WHERE name NOT IN (?,?,?)
        qw.notIn("name","张三","李四","周丽");
        print(qw);

    }

in 值列表

 /**
     * in 值列表
     */
    @Test
    public void testIn2(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        List<Object> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        //WHERE status IN (?,?)
        qw.in("status",list);
        print(qw);


    }

inSql() : 使用子查询

  /**
     * inSql() : 使用子查询
     */
    @Test
    public void testInSQL(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //WHERE age IN (select age from student where id=1)
        qw.inSql("age","select age from student where id=1");
        print(qw);
    }

notInSql() : 使用子查询

 /**
     * notInSql() : 使用子查询
     */
    @Test
    public void testNotInSQL(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //WHERE age NOT IN (select age from student where id=1)
        qw.notInSql("age","select age from student where id=1");
        print(qw);
    }

    private void print(QueryWrapper qw){
        List<Student> students = studentDao.selectList(qw);
        students.forEach(student -> System.out.println(student));
    }

groupBy：分组

   /**
     * groupBy：分组
     */
    @Test
    public void testGroupby(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.select("name,count(*) personNumbers");//select name,count(*) personNumbers
        qw.groupBy("name");
        // SELECT name,count(*) personNumbers FROM student GROUP BY name
        print(qw);
    }

orderbyAsc ： 按字段升序

   /**
     * orderbyAsc ： 按字段升序
     */
    @Test
    public void testOrderByAsc(){
        QueryWrapper<Student> qw= new QueryWrapper<>();
        //FROM student ORDER BY name ASC , age ASC
        qw.orderByAsc("name","age");
        print(qw);
    }

orderbyDesc ： 按字段降序

   /**
     * orderbyDesc ： 按字段降序
     */
    @Test
    public void testOrderByDesc(){
        QueryWrapper<Student> qw= new QueryWrapper<>();
        // ORDER BY name DESC , id DESC
        qw.orderByDesc("name","id");
        print(qw);
    }

order :指定字段和排序方向


    /**
     * order :指定字段和排序方向
     *
     * boolean condition : 条件内容是否加入到 sql语句的后面。
     * true：条件加入到sql语句
     * FROM student ORDER BY name ASC
     *
     * false:条件不加入到sql语句
     * FROM student
     */
    @Test
    public void testOrder(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.orderBy(true,true,"name")
                .orderBy(true,false,"age")
                .orderBy(true,false,"email");
        // name asc, age desc , email desc
        //FROM student ORDER BY name ASC , age DESC , email DESC
        print(qw);
    }

and ,or方法

 /**
     * and ,or方法
     */
    @Test
    public void testOr(){
        QueryWrapper<Student> qw= new QueryWrapper<>();
        //WHERE name = ? OR age = ?
        qw.eq("name","张三")
                .or()
                .eq("age",22);
        print(qw);
    }

last : 拼接sql语句到MP的sql语句的最后

    /**
     * last : 拼接sql语句到MP的sql语句的最后
     */
    @Test
    public void testLast(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        //SELECT id,name,age,email,status FROM student WHERE name = ? OR age = ? limit 1
        qw.eq("name","张三")
                .or()
                .eq("age",22)
                .last("limit 1");
        print(qw);

    }

exists : 判断条件

    /**
     * exists : 判断条件
     *
     * notExists
     */
    @Test
    public void testExists(){
        QueryWrapper<Student> qw= new QueryWrapper<>();
        //SELECT id,name,age,email,status FROM student
        // WHERE EXISTS (select id from student where age > 20)
        //qw.exists("select id from student where age > 90");

        //SELECT id,name,age,email,status FROM student WHERE
        // NOT EXISTS (select id from student where age > 90)

        qw.notExists("select id from student where age > 90");
        print(qw);
    }

分页


    /**
     * 分页：
     * 1.统计记录数，使用count(1)
     *    SELECT COUNT(1) FROM student WHERE age > ?
     * 2.实现分页，在sql语句的末尾加入 limit 0,3
     *    SELECT id,name,age,email,status FROM student WHERE age > ? LIMIT 0,3
     */
    @Test
    public void testPage(){
        QueryWrapper<Student> qw = new QueryWrapper<>();
        qw.gt("age",22);
        IPage<Student> page  = new Page<>();
        //设置分页的数据
        page.setCurrent(1);//第一页
        page.setSize(3);// 每页的记录数

        IPage<Student> result = studentDao.selectPage(page,qw);

        //获取分页后的记录
        List<Student> students = result.getRecords();
        System.out.println("students.size()="+students.size());
        //分页的信息
        long pages  = result.getPages();
        System.out.println("页数："+pages);
        System.out.println("总记录数："+result.getTotal());
        System.out.println("当前页码："+result.getCurrent());
        System.out.println("每页的记录数："+result.getSize());
    }
我是个菜鸡.
关注
专栏目录
MybatisPlus：Wrappers常见用法
程序员无羡的博客
05-05 397
MybatisPlus：Wrappers常见用法
Mybatis-Plus中的查(select)和 Wrapper条件构造器-详解 V2.0
qq_53437402的博客
08-07 1万+
Mybatis-Plus中 select 查询方法和 Wrapper 条件构造器的-使用。
mybatis-plus中wrapper的用法（详细）
alan_liuyue的博客
11-05 1万+
用到了wrapper，整理资料记录一下，以备后续复习。 目录------------（可点击相应目录直接跳转） 目录 一、条件构造器关系介绍 条件构造器关系介绍 ： wapper介绍 ： 二、项目实例 1、根据主键或者简单的查询条件进行查询 2、MyBatis-Plus还提供了Wrapper条件构造器，具体使用看如下代码： 三、具体使用操作 1、ge、gt、le、lt、isNull、isNotNull 2、eq、ne 3、between、notBetween 4、allEq..
Java学习 --- mybatisplus使用wrapper组装数据
qq_46093575的博客
03-09 2244
一、mybatisplus使用wrapper组装数据 @SpringBootTest public class wrapperTest { @Autowired private UserMapper userMapper; /** * 组装条件查询 */ @Test public void selectUserTest() { QueryWrapper<User> wrapper = new QueryWrapper
Mybatis-Plus 入门
程序员Sharry的博客
12-16 3274
Mybatis-Plus 入门： 1. 需要有SQL、Mybatis、Java、Maven工程的一些基础 2. Wrapper 条件构造器（重点） 3. CRUD 的学习与演示
MyBatis-Plus（六）Mapper的CRUD接口3：分页查询
Zack_tzh的博客
07-22 2万+
Mapper的CRUD接口3：分页查询 1、添加配置 MyBatis-Plus 提供了物理分页的功能，使用前我们需要要进行相关的插件配置： 逻辑分页与物理分页比较: 逻辑分页：内存开销比较大，在数据量比较小的情况下效率比物理分页高；在数据量很大的情况下，内存开销过大，容易内存溢出，不建议使用。 物理分页：内存开销比较小，在数据量比较小的情况下效率比逻辑分页还是低；在数据量很大的情况下，建议使用物理分页。 @EnableTransactionManagement @Configuration pu
mybatis-plus代码生成器模版代码
08-17
<artifactId>mybatis-plus-boot-starter <version>3.4.3</version> <!-- 请根据最新版本号替换 --> ``` 接着，配置代码生成器的相关参数，包括数据源信息、生成的包路径、作者信息等。这些参数可以通过Java代码...
Mybatis-plus自动生成代码
10-12
Mybatis-plus是一款基于Mybatis和Spring的轻量级框架，它扩展了Mybatis的功能，提供了更便捷的操作数据库的方式。在项目开发中，Mybatis-plus的一个重要特性就是其代码生成器，能够极大地提高开发效率，减少手动编写...
mybatis-plus-boot-starter-3.1.0.jar
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus-boot-starter-3.4.3.3.jar
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus-boot-starter-3.5.3.2.jar
最新发布
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
MybatisPlus从入门到放弃
Fortuneteller的博客
06-16 486
本文主要内容：MybatisPlus的使用 MybatisPlus快速入门 一、MybatisPlus简介 MybatisPlus是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生 二、快速开始 1、创建数据库 mybatis_plus 2、创建User表 CREATE TABLE user ( id BIGINT(20) NOT NULL COMMENT '主键ID', name VARCHAR(30) NULL DEFAULT NULL COMM
MyBatis-Plus 快速上手教程 ~
qq_45716120的博客
02-26 1139
Spring Boot + MyBatis-Plus 的快速上手教程 ~~~
Mybatis Plus 看这篇就够了，通俗易懂，一发入魂
vcj1009784814的博客
03-24 1万+
文章目录快速入门注解小结mp的默认行为排除非表字段核心功能CRUD接口Mapper CRUD接口Service CRUD 接口条件构造器使用示例其他Condition构造Wrapper时传入实体allEq方法lambda条件构造器其他CRUD接口说明selectMapsselectObjsselectCount自定义SQL原生mybatisMybatis-plus分页查询更新操作反思删除操作AR模式主键策略主键策略小结配置基本配置进阶配置小结代码生成器 Mybatis plus 是一款Mybatis增强工具
MyabtisPlus（高级查询）
qq_45525848的博客
11-15 1万+
mybatisplus查询基础使用
MyBatis】mybatis Plus 的Wrapper查询
qq_34874784的博客
06-18 1885
MP提供了很多Wrapper方便我们使用 Wrapper ： 条件构造抽象类，最顶端父类 AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件 QueryWrapper ： Entity 对象封装操作类，不是用lambda语法 UpdateWrapper ： Update 条件封装，用于Entity对象更新操作 AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。 LambdaQuery
Mybatis-plus 高级查询Wrapper
weixin_41012767的博客
01-12 883
查询条件 条件 说明 allEq 基于 map 的比较 eq 等于 = ne 不等于 <> gt 大于 > ge 大于等于 >= lt 小于 < le 小于等于 < between BETWEEN 值1 AND 值2 notBetween NOT BETWEEN 值1 AND 值2 like LIKE ‘%值%’ notLike NOT LIKE ‘%值%
一看就懂！MyBatisPlus @SELECT 中使用条件构造器Wrapper
热门推荐
大誌的博客
06-05 3万+
当自定义@SELECT语句后，直接传wrapper到方法上就行不通了 List<ArticleVo> list = articleDao.queryList(page,queryWrapper); @Select("SELECT\n" + "\tarticle.*, category. NAME category_name\n" + ...
JAVA使用Wrapper实现范围查询、多个范围查询等复杂查询
林临的博客
08-21 8946
开发java项目时, 如果需要实现范围查询, 或是多个范围查询等更复杂的查询, 往往需要设计复杂的接口入参, 为了简化开发, 本文通过设计一个基于MyBatis-Plus的Wrapper类条件构造器()的公共方法类, 以一种规范化的FROM接收入参, 实现复杂查询 同时, 此方法可以给所有查询统一添加默认查询条件, 如:是否删除、加盟商等 需要掌握的知识: 1.MyBatis-Plus 官网 2.条件构造器Wrapper 条件构造器 3.了解Wrapper和LambdaWrapper的区别 1.类 1.1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值