1.简介
MyBatis-Plus (简称MP)是一个MyBatis 的增强工具,在MyBatis的基础上只做增强不做改变,为简化开发、提高效率而生。
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操作
@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.自动映射
- 表名和实体类名映射->表名user 实体类名User
- 字段名和实体类属性名映射->字段名name 实体类属性名name
- 字段名下划线命名方式和实体类属性小驼峰命名方式映射->字段名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")
3.1.3.字段映射
当数据库字段和表实体类的属性不一致时,我们可以使用@TableField()注解改变字段和属性的映射,让注解中的名称和表字段保持一致
如:此时将数据库字段的名称我们改为username,在根据实体类的属性拼接SQL的使用,就会使用@TableField()中指定的名称username进行拼接,完成查询
数据库字段和表实体类的属性一致,框架在拼接SQL语句的时候,会使用属性名称直接拼接sql语句,例如:
SELECT id,username AS name,age,email,desc
FROM powershop_user
这条语句直接进行查询的时候,会出现错误。
原因是,desc属于关键字,不能直接用于sql查询,要解决这个问题就需要将desc字段加上`符号,将他变为不是关键字,才能完成查询,那这个个问题的根本也是改变生成的SQL语句的字段名称,也就是我们需要通过@TableField()改变实体类的属性名称。
3.1.4.字段失效
当数据库中有字段不希望被查询,我们可以通过@TableField(select=false)来隐藏
这个字段,那在拼接SQL语句的时候,就不会拼接这个字段
3.1.5.视图属性
在实际开发中,有些字段不需要数据库存储,但是却需要展示,需要要展示也就是意味着实体类中需要存在这个字段,我们称这些实体类中存在但是数据库中不存在的字段,叫做视图字段。
像这种视图字段,能够作为查询条件么,显示是不能的。因为数据车中没有这个字段,所以查
询字段如果包含这个字段,SQL语句会出现问题。我们通过@TableField(exist = false)
来去掉这个字段,不让他作为查询字段。
3.2.条件构造器
3.2.1.条件构造器介绍
将查询条件封装成对象。
抽象类不能创建对象，重点在实体类。
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 = userMapper.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
void 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
void 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<User> 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策略
解决主键自增问题。表的数据量很大，我们需要进行分表
水平拆分就是将一个大的表按照数据量进行拆分
垂直拆分就是将一个大的表按照字段进行拆分
拆分后的数据，有三点需求
- 拆分前后主键保持有序
- 主键唯一性
- 主键不要暴露数据量
雪花算法是由一个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">
<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());
}