开发者

史上最全MybatisPlus从入门到精通

开发者 https://www.devze.com 2025-08-14 11:54 出处：网络 作者： ☆致夏☆
目录1.简介2.基础篇2.1.通用mapper接口操作2.2.通用service接口操作3.进阶篇3.1.映射3.1.1.自动映射3.1.2.表映射3.1.3.字段映射3.1.4.字段失效3.1.5.视图属性3.2.条件构造器3.2.1.条件构造器介绍3.3.等值查询3.3.1.
相关专题：MybatisPlus从入门到精通MybatisPlus基础到进阶
目录
  • 1.简介
  • 2.基础篇
    • 2.1.通用mapper接口操作
    • 2.2.通用service接口操作
  • 3.进阶篇
    • 3.1.映射
      • 3.1.1.自动映射
      • 3.1.2.表映射
      • 3.1.3.字段映射
      • 3.1.4.字段失效
      • 3.1.5.视图属性
    • 3.2.条件构造器
      • 3.2.1.条件构造器介绍
    • 3.3.等值查询
      • 3.3.1. 单条件查询 eq
      • 3.3.2. 多条件查询 allEq
    • 3.4.范围查询
      • 3.4.1. gt,ge,lt,le的使用
      • 3.4.2.区间查询 between notbetween
    • 3.5.模糊查询
      • 3.5.1.全模糊匹配 like
      • 3.5.2.不包含模糊匹配 notLike
      • 3.5.3.左模糊匹配 likeLeft
      • 3.5.4.右模糊匹配 likeRight
    • 3.6.判空查询
      • 3.6.1. isNull，isNotNull
    • 3.7.包含查询
      • 3.7.1. in
      • 3.7.2. notIn
      • 3.7.3. inSql
      • 3.7.4. notInSql
    • 3.8.分组查询
      • 3.8.1. groupBy
    • 3.9.聚合查询
      • 3.9.1. having
    • 3.10.排序查询
      • 3.10.1.升序查询 orderByAsc
      • 3.10.2.降序查询 orderByDesc
      • 3.10.3.自定义排序查询 orderBy
    • 3.11.逻辑查询
      • 3.11.1.内嵌逻辑查询 func
      • 3.11.2. and
      • 3.11.3. or
      • 3.11.4. nested
    • 3.12.自定义查询
      • 3.12.1. apply
    • 3.13.分页查询
      • 3.13.1. last
    • 3.14. exists 查询
      • 3.14.1 exists
      • 3.14.2 notExists
    • 3.15. select 查询
    • 4.高级篇
      • 4.1.主键策略
        • 4.1.1.AUTO策略
        • 4.1.2.​​​​​INPUT策略
        • 4.1.3.ASSIGN_ID策略
        • 4.1.4.NONE策略
        • 4.1.5.ASSIGN_UUID策略
      • 4.2.分页
        • 4.2.1.MyBATisPlus分页插件
        • 4.2.2.自定义分页插件

    1.简介

    MyBatis-Plus (简称MP)是一个MyBatis 的增强工具,在MyBatis的基础上只做增强不做改变,为简化开发、提高效率而生。

    官方网址：MyBatis-Plus 为简化开发而生

    2.基础篇

    2.1.通用mapper接口操作

        @Test
    void selectList() {
        List<User> users = userMapper.selectList(null);
        System.out.println(users);
    }
    @Test
    void insert() {
        User user = new User();
        user.setId(6L);
        user.setName("Nike");
        user.setAge(33);
        user.setEmail("test6@example.com");
        userMapper.insert(user);
    }
    @Test
    void deleteOne() {
        userMapper.deleteById(6L);
    }
    @Test
    void updateById() {
        User user = new User();
        user.setId(6L);
        user.setName("迈克");
        user.setAge(35);
        user.setEmail("maike@powernode.com");
        userMapper.updateById(user);
    }
    @Test
    void selectById() {
        User user = userMapper.selectById(6L);
        System.out.println(user);
    }

    2.2.通用service接口操作

    直接在service实现简单的crud操作

    史上最全MybatisPlus从入门到精通

        @Test
    void insertService() {
        User user = new User();
        user.setId(7L);
        user.setName("zhangsan");
        user.setAge(35);
        user.setEmail("zhangsan@powernode.com");
        userService.save(user);
    }
    @Test
    void deleteService() {
        userService.removeById(7L);
    }
    @Test
    void updateService() {
        User user = new User();
        user.setId(6L);
        user.setAge(40);
        userService.updateById(user);
    }
    @Test
    void selectService() {
        List<User> users = userService.selectList();
        System.out.println(users);
    }

    3.进阶篇

    3.1.映射

    3.1.1.自动映射

    1. 表名和实体类名映射->表名user 实体类名User
    2. 字段名和实体类属性名映射->字段名name 实体类属性名name
    3. 字段名下划线命名方式和实体类属性小驼峰命名方式映射->字段名user_email 实体类属性名userEmail

    MybatisPlus支持这种映射规则,可以通过配置来设置

    map-underscore-to-camel-case:true  #表示支持下划线到驱它峰的映射
map-underscore-to-camel-case:false  #表示不支持下划线到驼峰的映射

    3.1.2.表映射

    通过@TableName()注解指定映射的数据库表名,就会按照指定的表名进行映射

    如：此时将数据库的表名改为powershop_user,要完成表名和实体类合名的映射,需要将实体

    类名也要指定为powershop_user

    全局配置

    全局配置后可删除注解@TableName("powershop_user")

    史上最全MybatisPlus从入门到精通

    3.1.3.字段映射

    当数据库字段和表实体类的属性不一致时,我们可以使用@TableField()注解改变字段和属性的映射,让注解中的名称和表字段保持一致

    如:此时将数据库字段的名称我们改为username,在根据实体类的属性拼接SQL的使用,就会使用@TableField()中指定的名称username进行拼接,完成查询

    史上最全MybatisPlus从入门到精通

    数据库字段和表实体类的属性一致,框架在拼接SQL语句的时候,会使用属性名称直接拼接sql语句,例如:

    SELECT id,username AS name,age,email,desc

    FROM powershop_user

    这条语句直接进行查询的时候,会出现错误。

    原因是,desc属于关键字,不能直接用于sql查询,要解决这个问题就需要将desc字段加上`符号,将他变为不是关键字,才能完成查询,那这个个问题的根本也是改变生成的SQL语句的字段名称,也就是我们需要通过@TableField()改变实体类的属性名称。

    史上最全MybatisPlus从入门到精通

    3.1.4.字段失效

    当数据库中有字段不希望被查询,我们可以通过@TableField(select=false)来隐藏

    这个字段,那在拼接SQL语句的时候,就不会拼接这个字段

    史上最全MybatisPlus从入门到精通

    3.1.5.视图属性

    在实际开发中,有些字段不需要数据库存储,但是却需要展示,需要要展示也就是意味着实体类中需要存在这个字段,我们称这些实体类中存在但是数据库中不存在的字段,叫做视图字段。

    像这种视图字段,能够作为查询条件么,显示是不能的。因为数据车中没有这个字段,所以查

    询字段如果包含这个字段,SQL语句会出现问题。我们通过@TableField(exist = false)

    来去掉这个字段,不让他作为查询字段。

    史上最全MybatisPlus从入门到精通

    3.2.条件构造器

    3.2.1.条件构造器介绍

    将查询条件封装成对象。

    抽象类不能创建对象，重点在实体类。

    史上最全MybatisPlus从入门到精通

    3.3.等值查询

    3.3.1. 单条件查询 eq

    QueryWrapper 和 LambdaQueryWrapper 的对比使用

        @Test
    void eq(){
        //1.创建条件查询对象
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2.设置查询条件,指定查询的字段和匹配的值
        queryWrapper.eq( "name", "Jack");
        //3.进行条件查询
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }
    @Test
    void eq2() {
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getName, "Jack");
        User user = userMapper.selectOne(lambdaQueryWrapper);
        System.out.println(user);
    }

    查询null值判断

    条件查询判断，如果值为null，则不作为查询条件 -> 查询所有

        @Test
    void isNull(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        lambdaQueryWrapper.eq(User::getName,name);
        // User user = userMapper.selectOne(lambdaQueryWrapper);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }
    @Test
    void isNull2(){
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        String name = null;
        lambdaQueryWrapper.eq(name != null,User::getName,name);
        // User user = userMapper.selectOne(lambdaQueryWrapper);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

    3.3.2. 多条件查询 allEq

        @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);
    }
    @Test
    void allEq2() {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name", "Tom");
        hashMap.put("age", null);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.allEq(hashMap, true);
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

    3.3.3. 不等条件查询 ne

        @Test
    void ne() {
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.ne(User::getName, "Tom");
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

    3.4.范围查询

    3.4.1. gt,ge,lt,le的使用

    大于-gt、 大于等于-ge、 小于-lt、 小于等于-le

    @Test
void gt(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    Integer age = 18;
    lambdaQueryWrapper.ge(User::getAge,age);
    //3.使用条件完成查询
    List<User> users = userMjavascriptapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.4.2.区间查询 between notbetween

        @Test
    void between(){
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.between(User::getAge,18,30);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }
    @Test
    void notBetween(){
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.设置条件，指定字段名称和值
        lambdaQueryWrapper.notBetween(User::getAge,18,30);
        //3.使用条件完成查询
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

    3.5.模糊查询

    3.5.1.全模糊匹配 like

    @Test
void like(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.like(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.5.2.不包含模糊匹配 notLike

    @Test
void notLike(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notLike(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.5.3.左模糊匹配 likeLeft

    左边模糊 %e

    @Test
void likeLeft(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.likeLeft(User::getName,"e");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.5.4.右模糊匹配 likeRight

    @Test
void likeLeft(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.likeLeft(User::getName,"J");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.6.判空查询

    3.6.1. isNull，isNotNull

    @Test
void isNull(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称
    lambdaQueryWrapper.isNull(User::getName);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
@Test
void isNotNull(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称
    lambdaQueryWrapper.isNotNull(User::getName);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.7.包含查询

    3.7.1. in

    字段=值or字段=值  -> in

    @Test
void in(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    ArrayList<Integer> arrayList = new ArrayList<>();
    Collections.addAll(arrayList,18,20,21);
    lambdaQueryWrapper.in(User::getAge,arrayList);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
@Test
void in2(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.in(User::getAge,18,20,21);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.7.2. notIn

    字段!=值and字段!=值   -> notIn

    @Test
void notIn(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    ArrayList<Integer> arrayList = new ArrayList<>();
    Collections.addAll(arrayList,18,20,21);
    lambdaQueryWrapper.notIn(User::getAge,arrayList);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
@Test
void notIn2(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notIn(User::getAge,18,20,21);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.7.3. inSql

    @Test
void inSql(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.inSql(User::getAge,"18,20,22");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
@Test
voikafbyqd inSql2(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.inSql(User::getAge,"select age from powershop_user where age > 20");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.7.4. notInSql

    @Test
void notInSql(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notInSql(User::getAge,"18,20,22");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}
@Test
void notInSql2(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定字段名称和值
    lambdaQueryWrapper.notInSql(User::getAge,"select age from powershop_user where age > 20");
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.8.分组查询

    3.8.1. groupBy

    @Test
void groupBy(){
    //1.创建QueryWrapper对象
   QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    //2.设置条件，指定字段名称和值
    queryWrapper.groupBy("age");
    queryWrapper.select("age,count(*) as field_count");
    //3.使用条件完成查询
    List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
    System.out.println(maps);
}

    3.9.聚合查询

    3.9.1. having

    having过滤分组后的数据，where过滤分组前的数据。

    @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);
}

    3.10.排序查询

    3.10.1.升序查询 orderByAsc

    @Test
void orderByAsc(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定升序排序字段
    lambdaQueryWrapper.orderByAsc(User::getAge,User::getId);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.10.2.降序查询 orderByDesc

    @Test
void orderByDesc(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.设置条件，指定降序排序字段
    lambdaQueryWrapper.orderByDesc(User::getAge,User::getId);
    //3.使用条件完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.10.3.自定义排序查询 orderBy

        @Test
    void orderBy() {
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //设置排序字段和排序的方式参数1:如果排序字段的值存在nuLL的时候,是否还要作为排序字段参与排序,参数2:是否是升序排序,参数3:排序字段
        lambdaQueryWrapper.orderBy(true, true, User::getAge);
        lambdaQueryWrapper.orderBy(true, false, User::getId);
        List<User> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

    3.11.逻辑查询

    3.11.1.内嵌逻辑查询 func

        @Test
    www.devze.comvoid func(){
        //1.创建QueryWrapper对象
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //2.构建逻辑判断语句
        /*lambdaQueryWrapper.func(new Consumer<LambdaQueryWrapper<User>>() {
            @Override
            public void accept(LambdaQueryWrapper<User> userLambdaQueryWrapper) {
                if(true) {
                    userLambdaQueryWrapper.eq(User::getId, 1);
                } else {
                    userLambdaQueryWrapper.ne(User::getId, 1);
                }
            }
        });*/
        lambdaQueryWrapper.func(i -> {
            if(true) {
                i.eq(User::getId, 1);
            }else {
                i.ne(User::getId, 1);
            }
        });
        //3.完成查询
        List<Ukafbyqser> users = userMapper.selectList(lambdaQueryWrapper);
        System.out.println(users);
    }

    3.11.2. and

    正常拼接默认就是and

    @Test
void and(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.gt(User::getAge,22).lt(User::getAge,30);
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    and嵌套

    @Test
void and2(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.eq(User::getName,"wang").and(i -> i.gt(User::getAge,26).or().lt(User::getAge,22));
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.11.3. or

    @Test
void or(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.lt(User::getAge,20).or().gt(User::getAge,23);
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    or嵌套

    @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);
}

    3.11.4. nested

    查询条件直接拼在where后面

    @Test
void nested(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.nested(i -> i.eq(User::getName, "Billie").ne(User::getAge, 22));
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.12.自定义查询

    3.12.1. apply

    查询条件通过字符串编写直接拼在where后面

    @Test
void apply(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.apply("id = 1");
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.13.分页查询

    3.13.1. last

    查询条件通过字符串编写直接拼在Sql语句最后

    @Test
void last(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建条件查询语句
    lambdaQueryWrapper.last("limit 0,2");
    //3.完成查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.14. exists 查询

    3.14.1 exists

    exists后的子查询如果有结果，则exists返回true，执行exits前的主查询语句；反之不执行主查询语句。

    @Test
void exists(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.exists("select id from powershop_user where age = 18");
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.14.2 notExists

    @Test
void notExists(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.notExists("select id from powershop_user where age = 33");
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    3.15. select 查询

    选择要查询的字段

    @Test
void select(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.构建查询条件
    lambdaQueryWrapper.select(User::getId,User::getName);
    //3.查询
    List<User> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

    4.高级篇

    4.1.主键策略

    4.1.1.AUTO策略

    该策略为跟随数据库表的主键递增策略，前提是数据库表的主键要设置为自增

    4.1.2.​​​​​INPUT策略

    该策略表示，必须由我们手动的插入id,否则无法添加数据

    4.1.3.ASSIGN_ID策略

    解决主键自增问题。表的数据量很大，我们需要进行分表

    水平拆分就是将一个大的表按照数据量进行拆分

    垂直拆分就是将一个大的表按照字段进行拆分

    拆分后的数据，有三点需求

    1. 拆分前后主键保持有序
    2. 主键唯一性
    3. 主键不要暴露数据量

    雪花算法是由一个64位的二进制组成的，最终就是一个Long类型的数值。

    主要分为四部分存储

    【1】1位的符号位，固定值为0

    【2】41位的时间戳

    【3】10位的机器码，包含5位机器id和5位服务id

    【4】12位的序列号

    数据表插入数据后发现一个19位长度的id,该id就是雪花算法生成的id,这是二级制的十进制表示形式

    4.1.4.NONE策略

    NONE策略表示不指定主键生成策略，当我们没有指定主键生成策略或者主键策略为NONE的时候，他跟随的是全局策略。默认是雪花算法策略。

    4.1.5.ASSIGN_UUID策略

    UUID（Universally Unique Identifier）全局唯一标识符，定义为一个字符串主键，采用32位数字组成，编码采用16进制，定义了在时间和空间都完全唯一的系统信息。

    UUID的编码规则：

    【1】1~8位采用系统时间，在系统时间上精确到毫秒级保证时间上的唯一性；

    【2】9~16位采用底层的IP地址，在服务器集群中的唯一性；

    【3】17~24位采用当前对象的HashCode值，在一个内部对象上的唯一性；

    【4】25~32位采用调用方法的一个随机数，在一个对象内的毫秒级的唯一性。

    通过以上4种策略可以保证唯一性。在系统中需要用到随机数的地方都可以考虑采用UUID算法。

    我们想要演示UUID的效果，需要改变一下表的字段类型和实体类的属性类型

    将数据库表的字段类型改为varchar(50)，将实体类的属性类型改为String,并指定主键生成策略为IdType.ASSIGN_UUID

    4.2.分页

    分页的本质就是需要设置一个拦截器，通过拦截器拦截了SQL，通过在SQL语句的结尾添加limit关键字，来实现分页的效果

    4.2.1.MybatisPlus分页插件

    【1】通过配置类来指定一个具体数据库的分页插件

    @Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.mysql));
        return interceptor;
    }
}

    【2】实现分页查询效果

    @Test
void selectPage(){
    //1.创建QueryWrapper对象
    LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    //2.创建分页查询对象,指定当前页和每页显示条数
    IPage<User> page = new Page<>(1,3);
    //3.执行分页查询
    userMapper.selectPage(page, lambdaQueryWrapper);
    //4.查看分页查询的结果
    System.out.println("当前页码值："+page.getCurrent());
    System.out.println("每页显示数："+page.getSize());
    System.out.println("总页数："+page.getPages());
    System.out.println("总条数："+page.getTotal());
    System.out.println("当前页数据："+page.getRecords());
}

    4.2.2.自定义分页插件

    【1】在UserMapper.XML映射配置文件中提供查询语句

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.powernode.mapper.UserMapper">
  http://www.devze.com   <select id="selectByName" resultType="com.powernode.domain.User">
        select * from powershop_user where name = #{name}
     </select>
</mapper>

    【2】在Mapper接口中提供对应的方法，方法中将IPage对象作为参数传入

    @Mapper
public interface UserMapper extends BaseMapper<User> {
       IPage<User> selectByName(IPage<User> page, String name);
}

    【3】实现分页查询效果

    @Test
void selectPage2(){
    //1.创建分页查询对象,指定当前页和每页显示条数
    IPage<User> page = new Page<>(1,2);
    //2.执行分页查询
    userMapper.selectByName(page,"Mary");
    //3.查看分页查询的结果
    System.out.println("当前页码值："+page.getCurrent());
    System.out.println("每页显示数："+page.getSize());
    System.out.println("总页数："+page.getPages());
    System.out.println("总条数："+page.getTotal());
    System.out.println("当前页数据："+page.getRecords());
}

    到此这篇关于史上最全MybatisPlus从入门到精通的文章就介绍到这了,更多相关MybatisPlus从入门到精通内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

    0

    上一篇:

    :下一篇

    更多 开发 相关资讯：

    精彩评论

    暂无评论...
    登录 注册
    Qedev.com
    验证码 换一张
    取 消

    关注公众号

    热门标签

    图文推荐

    使用c#进行串口通信的实现示例

    使用c#进行串口通信的实现示例
    Java Lombok中的@Data、@Getter、@Setter使用技巧全面指南

    Java Lombok中的@Data、@Getter、@Setter使用技巧全面指南
    在Trae IDE中创建Spring AI项目的实现步骤

    在Trae IDE中创建Spring AI项目的实现步骤
    Java集合中的链表与结构详解

    Java集合中的链表与结构详解
    springSecurity使用实战指南

    springSecurity使用实战指南
    基于Java实现根据周次生成数据的工具类

    基于Java实现根据周次生成数据的工具类
    基于SpringBoot实现简单的ELK日志搜索系统

    基于SpringBoot实现简单的ELK日志搜索系统
    Go语言并发定时任务之从Sleep到Context的8种写法全解析

    Go语言并发定时任务之从Sleep到Context的8种写法全解析

    开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

    法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

    Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9