高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

MybatisPlus入门学习笔记

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

MybatisPlus入门学习笔记

文章目录

1、简介2、特性3、入门案例

3.1、数据库(user1)3.2、创建一个SpringBoot项目3.3、导入依赖3.4、编写代码 4、基本CRUD

4.1、插入4.2、删除4.3、修改4.4、查询4.5、通用Service 5、常用注解

5.1、`@TableName`5.2、`@TableId`5.3、`@TableField`5.4、`@TableLogic` 6、条件构造器和常用接口

6.1、wapper介绍6.2、QueryWrapper6.3、UpdateWrapper6.4、带condition参数的方法6.5、LambdaQueryWrapper6.6、LambdaUpdateWrapper（和LambdaQueryWrapper一样） 7、插件

7.1、分页插件7.2、xml自定义分页7.3、乐观锁插件 8、通用枚举9、代码生成器10、多数据源11、MyBatisX插件

1、简介

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

2、特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分
CRUD 操作，更有强大的条件构造器，满足各类使用需求支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由
配置，完美解决主键问题支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强
大的 CRUD 操作支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、
Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等
同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、
Postgre、SQLServer 等多种数据库内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出
慢查询内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防
误操作 3、入门案例 3.1、数据库(user1)

3.2、创建一个SpringBoot项目


3.3、导入依赖 
		
            com.baomidou
            mybatis-plus-boot-starter
            3.4.2
        


        
            mysql
            mysql-connector-java
        

        
            org.projectlombok
            lombok
3.4、编写代码

application.yml 

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&useSSL=false
    username: root
    password: root


# 配置MyBatis日志
mybatis-plus:
	configuration:
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

注意：
1、驱动类driver-class-name
spring boot 2.0（内置jdbc5驱动），驱动类使用：
driver-class-name: com.mysql.jdbc.Driver
spring boot 2.1及以上（内置jdbc8驱动），驱动类使用：
driver-class-name: com.mysql.cj.jdbc.Driver
否则运行测试用例的时候会有 WARN 信息
2、连接地址url
MySQL5.7版本的url：
jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
MySQL8.0版本的url：
jdbc:mysql://localhost:3306/mybatis_plus?
serverTimezone=GMT%2B8&characterEncoding=utf-8&useSSL=false
否则运行测试用例报告如下错误：
java.sql.SQLException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or
represents more

启动类:MybaitsPlusApplication.class 

@SpringBootApplication
@MapperScan("com.mybaitsplus.mapper")//扫描mapper包
public class MybaitsPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybaitsPlusApplication.class, args);
    }
}

实体类：User1.class 

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User1 {
    private Long id;
    private String name;
    private int age;
    private String email;
}

添加mapper：UserMapper.class 

@Repository

public interface UserMapper extends baseMapper {
}

测试类：Test.class 

@SpringBootTest
public class Test {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        List list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }
}


注意：
IDEA在 userMapper 处报错，因为找不到注入的对象，因为类是动态创建的，但是程序可以正确
的执行。
为了避免报错，可以在mapper接口上添加 @Repository 注解
4、基本CRUD

MyBatis-Plus中的基本CRUD在内置的baseMapper中都已得到了实现，我们可以直接使用，可自行查看：

public interface baseMapper extends Mapper {

int insert(T entity);


int deleteById(Serializable id);


int deleteById(T entity);


int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);


int delete(@Param(Constants.WRAPPER) Wrapper queryWrapper);


int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);


int updateById(@Param(Constants.ENTITY) T entity);


int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER)
Wrapper updateWrapper);


T selectById(Serializable id);


List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);


List selectByMap(@Param(Constants.COLUMN_MAP) Map
columnMap);


default T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper) {
List ts = this.selectList(queryWrapper);
if (CollectionUtils.isNotEmpty(ts)) {
if (ts.size() != 1) {
throw ExceptionUtils.mpe("One record is expected, but the query
result is multiple records");
}
return ts.get(0);
}
return null;
}


Long selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);


List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);


List> selectMaps(@Param(Constants.WRAPPER) Wrapper
queryWrapper);


List selectObjs(@Param(Constants.WRAPPER) Wrapper queryWrapper);



> P selectPage(P page, @Param(Constants.WRAPPER)
Wrapper queryWrapper);



>> P selectMapsPage(P page,
@Param(Constants.WRAPPER) Wrapper queryWrapper);
}
 
4.1、插入 

	@Test
    public void testInsert(){
        User1 user = new User1();
        user.setName("pc");
        user.setAge(20);
        user.setEmail("333@qq.com");
        //INSERT INTO user1 ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
        int result = userMapper.insert(user);
        System.out.println("result:"+result);
        System.out.println("id:"+user.getId());//1505851691209162753
      //  这是因为MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id
    }

 
4.2、删除 

    @Test
    public void testDeleted(){
	
	      //通过id删除数据
		  //DELETE FROM user1 WHERe id=?
//        int result = userMapper.deleteById(1505121187740635138L);


        //根据map集合中所设置的条件删除用户信息
//        Map map =new HashMap<>();
//        map.put("name","zhn");
//        map.put("age",20);
		  //DELETE FROM user1 WHERe name = ? AND age = ?
//        int result = userMapper.deleteByMap(map);

        //通过多个id实现批量删除
        List list = Arrays.asList(1L, 2L, 3L);
        //DELETE FROM user1 WHERe id IN ( ? , ? , ? )
        int result = userMapper.deleteBatchIds(list);
        System.out.println("result:"+result);
    }

 
4.3、修改 

    @Test
    public void testUpdate(){
        User1 user = new User1();
        //只会修改设置了的属性，未设置的属性不会修改
        user.setId(1L);
        user.setName("pym");
        user.setAge(20);
        user.setEmail("1.com");
        //UPDATE user1 SET name=?, age=?, email=? WHERe id=?
        int result = userMapper.updateById(user);
        System.out.println("result:"+result);
    }

 
4.4、查询 

    @org.junit.jupiter.api.Test
    public void testSelect(){
          //通过id查询
          //SELECT id,name,age,email FROM user1 WHERe id=?
//        User1 user = userMapper.selectById(1L);
//        System.out.println(user);


        //根据多个id查询多个用户查询
        //SELECT id,name,age,email FROM user1 WHERe id IN ( ? , ? ,?)
//        List list = Arrays.asList(1L, 2L, 3L);
//        List users = userMapper.selectBatchIds(list);
//        users.forEach(System.out::println);


        //根据map集合中的条件来查询
        //SELECT id,name,age,email FROM user1 WHERe name = ? AND age = ?
//        Map map =new HashMap<>();
//        map.put("name","pym");
//        map.put("age",20);
//        List users = userMapper.selectByMap(map);
//        users.forEach(System.out::println);

        //查询所有数据
        //SELECT id,name,age,email FROM user1
        List users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

 

通过观察baseMapper中的方法，大多方法中都有Wrapper类型的形参，此为条件构造器，可针
对于SQL语句设置不同的条件，若没有条件，则可以为该形参赋值null，即查询（删除/修改）所
有数据

 
4.5、通用Service 

说明:
通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删
除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IbaseService 继承
Mybatis-Plus 提供的基类

 

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑
 详情查看源码IService和ServiceImpl
 

创建Service接口和实现类 

public interface UserService extends IService {
}



@Service
public class UserServiceImpl extends ServiceImpl implements UserService {
}

 

测试
 

    @Autowired
    private UserService userService;

    @Test
    public void testGetCount(){
        //查询总记录数
        long count = userService.count();
        System.out.println("总记录数:"+count);
    }

    @Test
    public void testInsertMore(){
    // SQL长度有限制，海量数据插入单条SQL无法实行，
	// 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
        //批量添加
        List list = new ArrayList<>();
        for (int i=1;i<10;i++){
            User1 user = new User1();
            user.setName("pc"+i);
            user.setAge(20+i);
            list.add(user);
        }
        //INSERT INTO user1 ( id, name, age ) VALUES ( ?, ?, ? )
        boolean b = userService.saveBatch(list);
        System.out.println(b);
    }

 

 
5、常用注解 
5.1、@TableName 

在使用MyBatis-Plus实现基本的CRUD时，我们并没有指定要操作的表，只是在Mapper接口继承baseMapper时，设置了泛型User，而操作的表为user表。由此得出结论，MyBatis-Plus在确定操作的表时，由baseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致。
 
 

若实体类类型的类名和要操作的表的表名不一致，会出现什么问题？
 我将表名由user1改为t_user1:
 
 （一）通过@TableName解决问题
 在实体类类型上添加@TableName("t_user1")，标识实体类对应的表，即可成功执行SQL语句
 
 （二）通过全局配置解决问题
 

在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_
 此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就
 不需要在每个实体类上通过@TableName标识实体类对应的表。
 

在application.yml中添加以下代码：
 

# 设置Mybatis-Plus的全局配置
mybatis-plus:
    global-config:
      db-config:
        # 设置实体类所对应的表的统一前缀
        table-prefix: t_

 
5.2、@TableId 

MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。
 

若实体类和表中表示主键的不是id，而是其他字段，例如uid，MyBatis-Plus会自动识别uid为主键列吗？我们实体类中的属性id改为uid，将表中的字段id也改为uid，测试：
 
 

（一）通过@TableId解决问题
 

在实体类中uid属性上通过@TableId将其标识为主键，即可成功执行SQL语句。
 
 （二）@TableId的value属性
 要通过@TableId注解的value属性，指定表中的主键字段，@TableId("uid")或@TableId(value="uid")
 

补充：
 @TableId的type属性：type属性用来定义主键策略。
 常用的主键策略：
 

值描述
IdType.ASSIGN_ID（默认）基于雪花算法的策略生成数据id，与数据库id是否设置自增无关
IdType.AUTO使用数据库的自增策略，注意，该类型请确保数据库设置了id自增，否则无效


配置全局主键策略：
 

mybatis-plus:
	configuration:
		# 配置MyBatis日志
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
	global-config:
		db-config:
			# 配置MyBatis-Plus操作表的默认前缀
			table-prefix: t_
			# 配置MyBatis-Plus的主键策略
			id-type: auto

 
5.3、@TableField 

我们可以发现，MyBatis-Plus在执行SQL语句时，要保证实体类中的属性名和表中的字段名一致.
 

如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？
 

a>情况1：
 若实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格。例如实体类属性userName，表中字段user_name此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格相当于在MyBatis中配置。
 

b>情况2：
 若实体类中的属性和表中的字段不满足情况1，例如实体类属性name，表中字段username
 此时需要在实体类属性上使用@TableField(“username”)设置属性所对应的字段名。
 
 
5.4、@TableLogic 

（一）逻辑删除：
 

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库
 中仍旧能看到此条数据记录使用场景：可以进行数据恢复 

（二）实现逻辑删除
 数据库中创建逻辑删除状态列，设置默认值为0。
 
 实体类中添加逻辑删除属性
 
 测试：
 测试删除功能，真正执行的是修改：
 
 
 测试查询功能，被逻辑删除的数据默认不会被查询：
 
 但是数据库中还是存在的：
 
 
6、条件构造器和常用接口 
6.1、wapper介绍 

 

Wrapper ： 条件构造抽象类，最顶端父类 
  
AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件 
    
QueryWrapper ： 查询条件封装UpdateWrapper ： Update 条件封装AbstractLambdaWrapper ： 使用Lambda 语法的条件构造抽象类 
      
LambdaQueryWrapper ：用于Lambda语法使用的查询WrapperLambdaUpdateWrapper ： Lambda 更新封装Wrapper    
6.2、QueryWrapper 

将数据库的数据改变成：
 
 

（一）组装查询条件
 

	@Test
    public void test01(){
        //查询用户名包含a，年龄在20到30之间，邮箱信息不为null的用户信息
         
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name","a")
                        .between("age",20,30)
                                .isNotNull("email");
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 


 （二）组装排序条件
 

	@Test
    public void test02(){
        //查询用户信息，按年龄降序查询用户，如果年龄相同则按id升序排列
         
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.orderByDesc("age")
                .orderByAsc("uid");
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 


 （三）组装删除条件
 在此之前，我们往数据库添加一行数据：
 
 

    @Test
    public void test03(){
        //删除email为空的用户
         
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("email");
        int result = userMapper.delete(queryWrapper);
        System.out.println("受影响的行数："+result);
    }

 


 （四）使用QueryWrapper实现修改功能
 

    @Test
    public void test04(){
        //将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
         
        QueryWrapper queryWrapper = new QueryWrapper<>();
        //两个条件之间的连接默认是and
        queryWrapper.gt("age", 20)
                .like("name","a")
                .or()
                .isNull("email");
        User1 user =new User1();
        user.setName("李白");
        user.setEmail("Tang.com");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数："+result);
    }

 


 （五）条件的优先级
 

lambda表达式
 

    @Test
    public void test05(){
        //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
        //lambda表达式内的逻辑优先运算
        //i->i.gt("age",20).or().isNull("email")这个是lambda表达式
         
        QueryWrapper queryWrapper = new QueryWrapper<>();

        queryWrapper.like("name","a")
                .and(i->i.gt("age",20).or().isNull("email"));
        User1 user =new User1();
        user.setName("李白");
        user.setEmail("Tang.com");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数："+result);
    }

 

（六）组装select子句
 之前的查询会默认查询表里面的全部字段，但是我们可以设置我们想查询的字段：
 

    @Test
    public void test06(){
        //查询用户信息的name和age字段
        
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.select("name","age","email");
        List> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

 


 （七）实现子查询
 

    @Test
    public void test07(){
        //查询id小于等于3的用户信息
        
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("uid","select uid from t_user1 where uid<=3");
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 

 
6.3、UpdateWrapper 

前面用QueryWrapper实现修改功能：
 
 

    @Test
    public void test08(){
        //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
        
        UpdateWrapper updateWrapper = new UpdateWrapper<>();
        updateWrapper.like("name","a")
                .and(i-> i.gt("age",20).or().isNull("email"))
                .set("name","pc").set("email","1.com");
                
        //这里必须要创建User对象，否则无法应用自动填充。如果没有自动填充，可以设置为null
        int result = userMapper.update(null, updateWrapper);
        System.out.println("受影响的行数："+result);
    }

 

 
6.4、带condition参数的方法 

在真正开发的过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。
 

思路一：
 

    @Test
    public void test09(){
        //定义查询条件，有可能为null（用户未输入或未选择）
        String name="";
        Integer ageBegin=20;
        Integer ageEnd=30;
        QueryWrapper queryWrapper = new QueryWrapper<>();
        if (StringUtils.isNotBlank(name)){
            //StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
            queryWrapper.like("name",name);
        }
        if (ageBegin !=null){
            queryWrapper.ge("age",ageBegin);
        }
        if (ageEnd != null){
            queryWrapper.le("age",ageEnd);
        }
        
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 

思路二：
 上面的实现方案没有问题，但是代码比较复杂，我们可以使用带condition参数的重载方法构建查询条件，简化代码的编写。
 
 

    @Test
    public void test010(){
        
        String name="";
        Integer ageBegin=20;
        Integer ageEnd=30;
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(name),"name",name)
                .ge(ageBegin != null,"age",ageBegin)
                .le(ageEnd != null,"age",ageEnd);
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 
6.5、LambdaQueryWrapper 

可以防止我们手动输入参数时敲错单词。
 

    @Test
    public void test011(){
        
        String name="a";
        Integer ageBegin=null;
        Integer ageEnd=30;
        LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
        //避免使用字符串表示字段，防止运行时错误
        queryWrapper.like(StringUtils.isNotBlank(name),User1::getName,name)
                .ge(ageBegin != null,User1::getAge,ageBegin)
                .ge(ageEnd != null,User1::getAge,ageEnd);
        List list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

 

 
6.6、LambdaUpdateWrapper（和LambdaQueryWrapper一样） 

使用之前的例子：
 

    @Test
    public void test012(){
        
        String name="a";
        Integer ageBegin=null;
        Integer ageEnd=30;
        LambdaUpdateWrapper updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.like(User1::getName,"a")
                .and(i-> i.gt(User1::getAge,20).or().isNull(User1::getEmail));
        updateWrapper.set(User1::getName,"pc").set(User1::getEmail,"1.com");
        int result = userMapper.update(null, updateWrapper);
        System.out.println("受影响的行数："+result);
    }

 
7、插件 
7.1、分页插件 

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能。
 

创建一个config包，添加配置类：MybatisPlusConfig.java 

@Configuration
@MapperScan("com.mybaitsplus.mapper")//可以将主类中扫描包的注解移到此处
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor= new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

 

测试：MybatisPlusPluginsTest.java 

@SpringBootTest
public class MybatisPlusPluginsTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testPage(){
        //设置分页参数
        Page page= new Page<>(1,3);
        userMapper.selectPage(page,null);
        //获取分页数据
        List list = page.getRecords();//获取当前页的数据
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }
}

 

 
7.2、xml自定义分页 

在UserMapper接口中定义抽象方法 

    
    Page selectPageVo(@Param("page") Page page, @Param("age") Integer age);

 

UserMapper.xml中编写SQL