--- theme: condensed-night-purple --- # Mybatis Plus分页实现逻辑整理（结合芋道整合进行解析） ![在这里插入图片描述](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d10d75afb60d48bfa12a9f9fc5b782e2~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1616\&h=916\&s=863721\&e=png\&b=121420) 我希望如春天般的你，身着白色的婚纱，向我奔赴而来，我愿意用全世界最温情的目光，朝着你的方向望去——姗姗来迟。 ## 1.背景介绍 > 官方文档首先，我们都知道`Mybatis Plus`是`Mybatis` 的升级版，只做了功能增强，不做代码变动，现在我们就对于`Mybatis Plus`的分页实现做一个介绍概括！ `MyBatis-Plus`分页实现主要通过`Page`对象来实现，该对象封装了分页相关的信息，例如当前页码、每页记录数等。以下是MyBatis-Plus分页实现的概述： 1. **Page对象：** MyBatis-Plus使用`Page`对象来表示分页信息。这个对象包含了当前页码、每页记录数、总记录数等信息。 2. **分页查询方法：** 在进行查询时，你可以通过传递`Page`对象来告诉MyBatis-Plus你需要进行分页查询。MyBatis-Plus会在执行查询语句时，根据`Page`对象的信息生成对应的分页SQL语句。 3. **分页插件：** MyBatis-Plus提供了分页插件，可以在项目配置中进行配置。这个插件会在执行SQL前自动拦截，根据`Page`对象的信息生成对应的分页SQL，并在查询结果中封装到`Page`对象中。 4. **返回结果：** 分页查询的结果将被封装到`Page`对象中，你可以通过该对象获取分页相关的信息，例如总记录数、总页数等，以及实际的查询结果列表。总体而言，`MyBatis-Plus`分页实现简化了分页查询的操作，通过传递`Page`对象即可轻松实现分页查询，无需手动编写复杂的分页SQL语句。这使得分页操作更加方便，同时也提高了代码的可维护性。 ## 2.代码结构 ![在这里插入图片描述](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7757646f75e948b295cc2b56cf07867c~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1920\&h=1080\&s=386332\&e=png\&b=2a2d33) ## 3.依赖导入和相关配置 **依赖导入** 首先，要想完成代码演示和功能实现，我们需要再pom文件中加入如下依赖 ```xml org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-test test com.mysql mysql-connector-j runtime com.alibaba druid-spring-boot-starter 1.2.20 com.baomidou mybatis-plus-boot-starter 3.5.3.1 org.projectlombok lombok true jakarta.validation jakarta.validation-api 2.0.2 cn.hutool hutool-all 5.8.22 com.github.yulichang mybatis-plus-join-core 1.4.7 ``` 当然，让我们逐个介绍这些依赖项： 1. **org.springframework.boot:spring-boot-starter-web:** * **描述：** 提供了构建基于Spring Boot的Web应用程序所需的基本依赖项。包括处理HTTP请求、管理会话和提供静态资源等功能。 * **用途：** 通常用于开发Spring Boot Web应用程序。 2. **org.springframework.boot:spring-boot-starter-test:** * **描述：** 包含用于测试Spring Boot应用程序的依赖项。提供对单元测试、集成测试等测试相关功能的支持。 * **用途：** 用于编写Spring Boot应用程序的测试。 3. **com.mysql:mysql-connector-j:** * **描述：** MySQL官方的JDBC驱动程序，用于将Java应用程序连接到MySQL数据库。 * **用途：** 当Spring Boot应用程序需要与MySQL数据库进行连接时使用。 4. **com.alibaba:druid-spring-boot-starter:1.2.20:** * **描述：** 集成了Druid连接池，它是一个高性能的开源JDBC连接池，还提供了监控和管理功能。 * **用途：** 当你想要使用Druid作为数据库连接池并享受其监控和管理功能时使用。 5. **com.baomidou:mybatis-plus-boot-starter:3.5.3.1:** * **描述：** MyBatis-Plus是MyBatis的增强工具包，简化了MyBatis的使用，提供了许多便利功能，包括分页查询。 * **用途：** 用于简化MyBatis的使用，包括分页查询等功能。 6. **org.projectlombok:lombok:** * **描述：** Lombok是一个Java库，通过注解消除了样板代码，提高了开发效率。 * **用途：** 简化Java代码，减少样板代码的编写。 7. **jakarta.validation:jakarta.validation-api:2.0.2:** * **描述：** Jakarta Bean Validation API，提供了一套用于声明性数据验证的API。 * **用途：** 用于在应用程序中执行数据验证。 8. **cn.hutool:hutool-all:5.8.22:** * **描述：** Hutool是一个Java工具包，提供了许多实用的工具方法，简化了Java开发。 * **用途：** 提供各种实用工具，简化Java开发中的常见任务。 9. **com.github.yulichang:mybatis-plus-join-core:1.4.7:** * **描述：** 一个用于MyBatis-Plus的插件，简化了多表关联查询的操作。 * **用途：** 简化MyBatis-Plus中多表关联查询的实现。 **基础配置** ```xml server: port: 8181 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/yudao?useUnicode=true&characterEncoding=UTF-8 username: root password: root mybatis-plus: mapper-locations: classpath:/mapper/**/*.xml typeAliasesPackage: com.cnbai.*.* global-config: db-config: id-type: AUTO # 数据库字段驼峰下划线转换 db-column-underline: true refresh-mapper: true configuration: # 自动驼峰命名 map-underscore-to-camel-case: true # 查询结果中包含空值的列，在映射的时候，不会映射这个字段 call-setters-on-nulls: true # 开启 sql 日志 log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 关闭 sql 日志 # log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl ``` 这是一个Spring Boot项目的配置文件，主要包含了服务器端口、数据库连接信息以及MyBatis-Plus的配置。下面是对其中的关键配置项的解读： * `server.port`: 配置了应用的端口号，这里设置为8181。 * `spring.datasource`: 配置了数据源相关信息。 * `driver-class-name`: 指定了数据库驱动的类名。 * `url`: 指定了数据库连接的URL，包括数据库类型、主机地址、端口号以及数据库名称等。 * `username` 和 `password`: 指定了数据库的用户名和密码。 * `mybatis-plus.mapper-locations`: 指定了MyBatis Mapper XML 文件的位置。 * `mybatis-plus.typeAliasesPackage`: 指定了MyBatis扫描实体类别名的包路径。 * `mybatis-plus.global-config`: 全局配置，包括数据库配置和刷新映射器。 * `db-config.id-type`: 设置主键生成策略，这里设定为自动增长。 * `db-config.db-column-underline`: 数据库字段驼峰下划线转换，设置为true表示启用。 * `db-config.refresh-mapper`: 刷新映射器，设置为true表示刷新XML中的缓存。 * `mybatis-plus.configuration`: MyBatis 配置项。 * `map-underscore-to-camel-case`: 开启自动驼峰命名。 * `call-setters-on-nulls`: 查询结果中包含空值的列，在映射时不会映射这个字段，设置为true表示调用setter方法设置null值。 * `log-impl`: 开启 SQL 日志，这里设置为在控制台输出。总体而言，这份配置文件包括了服务器端口、数据库连接信息，以及MyBatis-Plus的配置，其中包含了数据库驱动、URL、用户名、密码、Mapper XML 文件位置、实体类别名扫描包路径等。 MyBatis-Plus的配置包括了全局配置和MyBatis的一些常用配置，如主键生成策略、字段命名策略、映射器刷新等。 ## 4.编写MybatisPlusConfig配置类这是一个使用MyBatis-Plus的配置类，主要用于配置分页插件。让我对这段代码进行解读一下： ```java @Configuration public class MybatisPlusConfig { /** * 添加分页插件 */ @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 如果配置多个插件, 切记分页最后添加 return interceptor; } } ``` 1. `@Configuration`: 这个注解表示这是一个配置类，会被Spring容器扫描并加载。 2. `@Bean`: 这个注解标志着这是一个Bean的定义方法，它将返回一个被Spring管理的对象。 3. `MybatisPlusInterceptor`: 这是MyBatis-Plus提供的插件拦截器，用于自定义MyBatis的行为。 4. `mybatisPlusInterceptor()`: 这个方法用于创建并配置`MybatisPlusInterceptor`的实例。 5. `interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL))`: 这行代码添加了一个内部插件，即`PaginationInnerInterceptor`，用于实现分页功能。`DbType.MYSQL`指定了数据库类型为MySQL。如果有多个插件，要确保分页插件是最后一个添加，以确保正确的执行顺序。总体来说，这段配置代码的作用是创建一个MyBatis-Plus的拦截器，配置了分页插件，确保在进行数据库查询时自动添加分页的功能。这样，你在使用MyBatis-Plus进行分页查询时就无需手动编写分页SQL，而是通过配置实现了分页的自动化。 ## 5.创建基础工具类 ### `PageParam`分页基础实体类 ```java import lombok.Data; import javax.validation.constraints.Min; import javax.validation.constraints.Max; import javax.validation.constraints.NotNull; import java.io.Serializable; @Data public class PageParam implements Serializable { private static final Integer PAGE_NO = 1; private static final Integer PAGE_SIZE = 10; /** * 每页条数 - 不分页 * * 例如说，导出接口，可以设置 {@link #pageSize} 为 -1 不分页，查询所有数据。 */ public static final Integer PAGE_SIZE_NONE = -1; @NotNull(message = "页码不能为空") @Min(value = 1, message = "页码最小值为 1") private Integer pageNo = PAGE_NO; @NotNull(message = "每页条数不能为空") @Min(value = 1, message = "每页条数最小值为 1") @Max(value = 100, message = "每页条数最大值为 100") private Integer pageSize = PAGE_SIZE; } ``` > 这个类定义了用于分页查询的参数，通过 Lombok 注解减少了冗长的 getter 和 setter 方法的编写，而通过 Bean Validation 注解确保了参数的合法性。其中，通过静态常量和注释提供了对默认分页参数和不分页情况的解释 ### `PageResult`分页基础实体类 ```java import java.io.Serializable; import java.util.ArrayList; import java.util.List; @Data public final class PageResult implements Serializable { private List list; private Long total; public PageResult() { } public PageResult(List list, Long total) { this.list = list; this.total = total; } public PageResult(Long total) { this.list = new ArrayList<>(); this.total = total; } public static PageResult empty() { return new PageResult<>(0L); } public static PageResult empty(Long total) { return new PageResult<>(total); } } ``` 这是一个用于表示分页查询结果的 Java 类 `PageResult`，使用 Lombok 的 `@Data` 注解简化了 getter、setter、toString 等方法的编写。下面是对该类的解读： 1. `PageResult` 是一个泛型类，使用了 `` 来表示泛型类型，用于表示分页查询的结果。 2. `list` 属性：表示分页查询的结果列表，其中的泛型 `T` 表示每个元素的类型。 3. `total` 属性：表示总记录数，即满足查询条件的所有记录的数量。 4. 有多个构造方法： * 无参构造方法：用于创建一个空的 `PageResult` 对象。 * 带参构造方法（`List list, Long total`）：用于接收查询结果列表和总记录数。 * 带参构造方法（`Long total`）：用于接收总记录数，结果列表初始化为空列表。 5. 静态方法： * `empty()`: 返回一个空的 `PageResult`，总记录数为 0。 * `empty(Long total)`: 返回一个空的 `PageResult`，可以指定总记录数。这个类的设计主要是用于封装分页查询的结果，提供了一些方便的构造方法和静态方法，使得在业务代码中使用起来更加简洁。 ### BaseMapperX 工具类 **在MyBatis Plus 的 BaseMapper 的基础上拓展** ```java import cn.hutool.core.collection.CollUtil; import com.baomidou.mybatisplus.core.conditions.Wrapper; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.support.SFunction; import com.baomidou.mybatisplus.extension.toolkit.Db; import com.github.yulichang.base.MPJBaseMapper; import com.github.yulichang.interfaces.MPJBaseJoin; import com.page.demo.common.mybatis.core.query.MyBatisUtils; import com.page.demo.common.pojo.PageParam; import com.page.demo.common.pojo.PageResult; import org.apache.ibatis.annotations.Param; import java.util.Collection; import java.util.List; /** * 在 MyBatis Plus 的 BaseMapper 的基础上拓展，提供更多的能力 * * 1. {@link BaseMapper} 为 MyBatis Plus 的基础接口，提供基础的 CRUD 能力 * 2. {@link MPJBaseMapper} 为 MyBatis Plus Join 的基础接口，提供连表 Join 能力 */ public interface BaseMapperX extends MPJBaseMapper { default PageResult selectPage(PageParam pageParam, @Param("ew") Wrapper queryWrapper) { // 特殊：不分页，直接查询全部 if (PageParam.PAGE_SIZE_NONE.equals(pageParam.getPageNo())) { List list = selectList(queryWrapper); return new PageResult<>(list, (long) list.size()); } // MyBatis Plus 查询 IPage mpPage = MyBatisUtils.buildPage(pageParam); selectPage(mpPage, queryWrapper); // 转换返回 return new PageResult<>(mpPage.getRecords(), mpPage.getTotal()); } default PageResult selectJoinPage(PageParam pageParam, Class resultTypeClass, MPJBaseJoin joinQueryWrapper) { IPage mpPage = MyBatisUtils.buildPage(pageParam); selectJoinPage(mpPage, resultTypeClass, joinQueryWrapper); // 转换返回 return new PageResult<>(mpPage.getRecords(), mpPage.getTotal()); } default T selectOne(String field, Object value) { return selectOne(new QueryWrapper().eq(field, value)); } default T selectOne(SFunction field, Object value) { return selectOne(new LambdaQueryWrapper().eq(field, value)); } default T selectOne(String field1, Object value1, String field2, Object value2) { return selectOne(new QueryWrapper().eq(field1, value1).eq(field2, value2)); } default T selectOne(SFunction field1, Object value1, SFunction field2, Object value2) { return selectOne(new LambdaQueryWrapper().eq(field1, value1).eq(field2, value2)); } default T selectOne(SFunction field1, Object value1, SFunction field2, Object value2, SFunction field3, Object value3) { return selectOne(new LambdaQueryWrapper().eq(field1, value1).eq(field2, value2) .eq(field3, value3)); } default Long selectCount() { return selectCount(new QueryWrapper<>()); } default Long selectCount(String field, Object value) { return selectCount(new QueryWrapper().eq(field, value)); } default Long selectCount(SFunction field, Object value) { return selectCount(new LambdaQueryWrapper().eq(field, value)); } default List selectList() { return selectList(new QueryWrapper<>()); } default List selectList(String field, Object value) { return selectList(new QueryWrapper().eq(field, value)); } default List selectList(SFunction field, Object value) { return selectList(new LambdaQueryWrapper().eq(field, value)); } default List selectList(String field, Collection values) { if (CollUtil.isEmpty(values)) { return CollUtil.newArrayList(); } return selectList(new QueryWrapper().in(field, values)); } default List selectList(SFunction field, Collection values) { if (CollUtil.isEmpty(values)) { return CollUtil.newArrayList(); } return selectList(new LambdaQueryWrapper().in(field, values)); } @Deprecated default List selectList(SFunction leField, SFunction geField, Object value) { return selectList(new LambdaQueryWrapper().le(leField, value).ge(geField, value)); } default List selectList(SFunction field1, Object value1, SFunction field2, Object value2) { return selectList(new LambdaQueryWrapper().eq(field1, value1).eq(field2, value2)); } /** * 批量插入，适合大量数据插入 * * @param entities 实体们 */ default void insertBatch(Collection entities) { Db.saveBatch(entities); } /** * 批量插入，适合大量数据插入 * * @param entities 实体们 * @param size 插入数量 Db.saveBatch 默认为 1000 */ default void insertBatch(Collection entities, int size) { Db.saveBatch(entities, size); } default void updateBatch(T update) { update(update, new QueryWrapper<>()); } default void updateBatch(Collection entities) { Db.updateBatchById(entities); } default void updateBatch(Collection entities, int size) { Db.updateBatchById(entities, size); } default void insertOrUpdate(T entity) { Db.saveOrUpdate(entity); } default void insertOrUpdateBatch(Collection collection) { Db.saveOrUpdateBatch(collection); } default int delete(String field, String value) { return delete(new QueryWrapper().eq(field, value)); } default int delete(SFunction field, Object value) { return delete(new LambdaQueryWrapper().eq(field, value)); } } ``` 这是一个自定义的 MyBatis Plus 的 Mapper 接口 `BaseMapperX`，该接口继承了 `MPJBaseMapper`。下面是对该接口的主要内容进行解读： 1. `BaseMapperX` 继承了 `MPJBaseMapper`，这表示该 Mapper 接口扩展了 MyBatis Plus 的基础 Mapper 接口，并具有更多的能力。 2. 接口中包含了一系列的默认方法，这些方法提供了更方便的数据库操作。以下是其中的几个方法的说明： * `selectPage`: 根据传入的分页参数和查询条件，进行分页查询并返回 `PageResult`。 * `selectJoinPage`: 进行关联查询，支持连表 Join 操作，返回 `PageResult`，其中 DTO 是关联查询结果的数据传输对象。 * `selectOne` 系列方法：根据传入的条件查询单个对象。 * `selectCount` 系列方法：根据条件查询符合条件的记录数量。 * `selectList` 系列方法：根据条件查询符合条件的记录列表。 * `insertBatch` 系列方法：批量插入数据。 * `updateBatch` 系列方法：批量更新数据。 * `insertOrUpdate` 和 `insertOrUpdateBatch`：插入或更新数据。 * `delete` 系列方法：根据条件删除数据。 3. 该接口中使用了一些 MyBatis Plus 的条件构造器，如 `QueryWrapper` 和 `LambdaQueryWrapper`，用于构建查询条件。 4. 在一些批量操作方法中，使用了 `Db` 类提供的方法，该类提供了一些数据库操作的工具方法，例如批量插入、批量更新等。总体而言，`BaseMapperX` 接口提供了一组扩展的数据库操作方法，使得在使用 MyBatis Plus 进行数据库操作时更加方便和灵活。 ### `LambdaQueryWrapperX` 优化构建器 ```java import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ObjectUtil; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.toolkit.support.SFunction; import org.springframework.util.StringUtils; import java.util.Collection; /** * 拓展 MyBatis Plus QueryWrapper 类，主要增加如下功能： *

* 1. 拼接条件的方法，增加 xxxIfPresent 方法，用于判断值不存在的时候，不要拼接到条件中。 * * @param 数据类型 */ public class LambdaQueryWrapperX extends LambdaQueryWrapper { public LambdaQueryWrapperX likeIfPresent(SFunction column, String val) { if (StringUtils.hasText(val)) { return (LambdaQueryWrapperX) super.like(column, val); } return this; } public LambdaQueryWrapperX inIfPresent(SFunction column, Collection values) { if (ObjectUtil.isAllNotEmpty(values) && !ArrayUtil.isEmpty(values)) { return (LambdaQueryWrapperX) super.in(column, values); } return this; } public LambdaQueryWrapperX inIfPresent(SFunction column, Object... values) { if (ObjectUtil.isAllNotEmpty(values) && !ArrayUtil.isEmpty(values)) { return (LambdaQueryWrapperX) super.in(column, values); } return this; } public LambdaQueryWrapperX eqIfPresent(SFunction column, Object val) { if (ObjectUtil.isNotEmpty(val)) { return (LambdaQueryWrapperX) super.eq(column, val); } return this; } public LambdaQueryWrapperX neIfPresent(SFunction column, Object val) { if (ObjectUtil.isNotEmpty(val)) { return (LambdaQueryWrapperX) super.ne(column, val); } return this; } public LambdaQueryWrapperX gtIfPresent(SFunction column, Object val) { if (val != null) { return (LambdaQueryWrapperX) super.gt(column, val); } return this; } public LambdaQueryWrapperX geIfPresent(SFunction column, Object val) { if (val != null) { return (LambdaQueryWrapperX) super.ge(column, val); } return this; } public LambdaQueryWrapperX ltIfPresent(SFunction column, Object val) { if (val != null) { return (LambdaQueryWrapperX) super.lt(column, val); } return this; } public LambdaQueryWrapperX leIfPresent(SFunction column, Object val) { if (val != null) { return (LambdaQueryWrapperX) super.le(column, val); } return this; } public LambdaQueryWrapperX betweenIfPresent(SFunction column, Object val1, Object val2) { if (val1 != null && val2 != null) { return (LambdaQueryWrapperX) super.between(column, val1, val2); } if (val1 != null) { return (LambdaQueryWrapperX) ge(column, val1); } if (val2 != null) { return (LambdaQueryWrapperX) le(column, val2); } return this; } // ========== 重写父类方法，方便链式调用 ========== @Override public LambdaQueryWrapperX eq(boolean condition, SFunction column, Object val) { super.eq(condition, column, val); return this; } @Override public LambdaQueryWrapperX eq(SFunction column, Object val) { super.eq(column, val); return this; } @Override public LambdaQueryWrapperX orderByDesc(SFunction column) { super.orderByDesc(true, column); return this; } @Override public LambdaQueryWrapperX last(String lastSql) { super.last(lastSql); return this; } @Override public LambdaQueryWrapperX in(SFunction column, Collection coll) { super.in(column, coll); return this; } } ``` 这是一个拓展了 MyBatis Plus 的 `LambdaQueryWrapper` 类的 `LambdaQueryWrapperX` 类。主要增加了一些方法，用于在条件拼接时判断值是否存在，从而决定是否拼接到条件中。以下是对该类的解读： 1. `LambdaQueryWrapperX` 继承了 `LambdaQueryWrapper`，表示该类是对 `LambdaQueryWrapper` 的拓展。 2. 该类提供了一系列的拓展方法，如 `likeIfPresent`、`inIfPresent`、`eqIfPresent` 等，这些方法都带有 `IfPresent` 后缀，表示当值存在时才进行条件拼接，避免了值为 null 或空时拼接条件。 3. 这些拓展方法在条件拼接时先判断了值的存在性，如果值存在才进行条件拼接，否则不拼接。 4. 重写了父类的一些方法，以方便链式调用，例如 `eq`、`orderByDesc`、`last`、`in` 等。总体而言，该类通过增加带有 `IfPresent` 后缀的拓展方法，使得在使用 `LambdaQueryWrapper` 进行条件拼接时更加方便，减少了空值或 null 值导致的冗余条件拼接。 ## 6.创建实体类 ```java @Data @TableName(value = "test_student") public class Student { @TableId private Long stuId; private String stuName; private Long stuAge; private String className; } ``` ## 7.创建请求视图对象 ```java @Data @EqualsAndHashCode(callSuper = true) public class StudentPageReqVO extends PageParam { private String stuName; private String className; } ``` **在这里有必要做一个解释，为什么创建一个请求视图对象** 创建请求视图对象（Request View Object，简称Request VO）有几个主要原因，尤其在Web开发中： 1. **封装请求参数：** Request VO 提供了一种将请求参数封装到一个对象中的方式。这样做有助于减少控制器（Controller）层中的方法签名中的参数数量。在处理复杂的请求，特别是包含多个参数的请求时，将它们组织成一个对象可以提高代码的清晰度和可读性。 2. **传递前端数据：** 在Web应用中，前端通常以 JSON 或其他数据格式将数据传递给后端。Request VO 用于在前端和后端之间传递数据，尤其是在处理复杂的表单提交或查询条件时。通过使用 Request VO，可以更方便地将前端的数据映射到后端的处理逻辑中。 3. **解耦前后端：** Request VO 有助于解耦前端和后端的实现细节。前端可以更自由地修改请求参数的结构，而后端的处理逻辑不会受到太大影响，只需保证 Request VO 中的字段与后端期望的数据结构相匹配即可。 4. **提高代码复用性：** Request VO 可以作为方法参数，提高了代码的复用性。例如，多个控制器方法可能需要相似的请求参数，通过使用相同的 Request VO，可以减少重复的代码。 5. **易于维护：** 维护 Request VO 可以更方便地处理接口变更。如果请求参数的结构发生变化，只需更新 Request VO 中的字段，而无需修改控制器方法的签名。总体而言，创建请求视图对象是一种良好的实践，有助于组织和管理请求参数，提高代码的可读性、可维护性，并支持前后端的解耦。 `extends PageParam` 表示一个类继承了 `PageParam`，这种情况通常发生在使用某个框架或库提供的分页功能时。 ## 8.创建Mapper层 ```java import com.page.demo.common.mybatis.core.query.LambdaQueryWrapperX; import com.page.demo.common.mybatis.core.query.mapper.BaseMapperX; import com.page.demo.common.pojo.PageResult; import com.page.demo.domain.Student; import com.page.demo.domain.StudentPageReqVO; import org.apache.ibatis.annotations.Mapper; @Mapper public interface StudentMapper extends BaseMapperX { default PageResult getStudentList(StudentPageReqVO reqVO) { return selectPage(reqVO, new LambdaQueryWrapperX() .likeIfPresent(Student::getStuName, reqVO.getStuName()) .likeIfPresent(Student::getClassName, reqVO.getClassName()) .orderByDesc(Student::getStuId)); } } ``` 在这里我们可以看到，我们有三个自定义的基础工具类 > ```java > com.page.demo.common.mybatis.core.query.LambdaQueryWrapperX; > com.page.demo.common.mybatis.core.query.mapper.BaseMapperX; > com.page.demo.common.pojo.PageResult; > ``` 就是我们首先创建的工具对象。这是一个在 `StudentMapper` 接口中定义的默认方法，用于获取学生列表并返回分页结果 `PageResult`。以下是对该方法的解读： 1. **方法签名：** ```java default PageResult getStudentList(StudentPageReqVO reqVO) ``` * 返回类型：`PageResult`，表示分页查询的结果，其中 `Student` 是学生实体类。 * 方法名称：`getStudentList`，用于获取学生列表。 * 参数：`StudentPageReqVO reqVO`，是一个请求视图对象，用于传递查询条件。 2. **方法实现：** ```java return selectPage(reqVO, new LambdaQueryWrapperX() .likeIfPresent(Student::getStuName, reqVO.getStuName()) .likeIfPresent(Student::getClassName, reqVO.getClassName()) .orderByDesc(Student::getStuId)); ``` * `selectPage` 是在 `BaseMapperX` 接口中定义的方法，用于执行分页查询。 * `reqVO` 作为查询条件传入。 * `new LambdaQueryWrapperX()` 创建了一个带有条件判断的 LambdaQueryWrapper 实例，该实例是对 MyBatis Plus 的 LambdaQueryWrapper 进行了扩展，使得条件在值存在时才拼接到查询条件中。 * `.likeIfPresent(Student::getStuName, reqVO.getStuName())`：如果 `reqVO.getStuName()` 不为空，则添加一个类似于 `like` 的条件，即根据学生姓名模糊查询。 * `.likeIfPresent(Student::getClassName, reqVO.getClassName())`：如果 `reqVO.getClassName()` 不为空，则添加一个类似于 `like` 的条件，即根据班级名称模糊查询。 * `.orderByDesc(Student::getStuId)`：按照学生编号降序排列结果。 3. **返回结果：** * 返回的是经过分页查询后的学生列表的分页结果，封装在 `PageResult` 中。总体而言，这个方法实现了根据给定的条件（从 `reqVO` 中获取）进行学生列表的分页查询，使用了 MyBatis Plus 提供的分页查询功能，并且在查询条件拼接时使用了自定义的 `LambdaQueryWrapperX` 类，确保只有在条件值存在的情况下才进行条件的拼接。 ## 9.创建服务层接口 ```java import com.baomidou.mybatisplus.extension.service.IService; import com.page.demo.common.pojo.PageResult; import com.page.demo.domain.Student; import com.page.demo.domain.StudentPageReqVO; public interface IStudentService extends IService { PageResult getStudentList(StudentPageReqVO reqVO); } ``` ## 10.创建服务层接口实现类 ```java import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.page.demo.common.pojo.PageResult; import com.page.demo.domain.Student; import com.page.demo.domain.StudentPageReqVO; import com.page.demo.mapper.StudentMapper; import com.page.demo.service.IStudentService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import javax.annotation.Resource; @Service public class StudentServiceImpl extends ServiceImpl implements IStudentService { @Resource private StudentMapper studentMapper; @Override public PageResult getStudentList(StudentPageReqVO reqVO) { return studentMapper.getStudentList(reqVO); } } ``` ## 11.创建控制层 ```java import cn.hutool.json.JSONObject; import com.page.demo.common.pojo.PageResult; import com.page.demo.domain.Student; import com.page.demo.domain.StudentPageReqVO; import com.page.demo.service.IStudentService; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; import java.util.List; @RestController @RequestMapping("/api/stu") public class StudentController { @Resource private IStudentService studentService; @GetMapping("/list") public JSONObject getStudentList(StudentPageReqVO reqVO) { PageResult pageResult = studentService.getStudentList(reqVO); JSONObject jsonObject = new JSONObject(); jsonObject.set("data", pageResult); jsonObject.set("status", 200); return jsonObject; } } ``` ## 12.测试 ![在这里插入图片描述](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ba1c3cbe44b940798da8c6cd09b55c15~tplv-k3u1fbpfcp-jj-mark:0:0:0:0:q75.image#?w=1603\&h=909\&s=112144\&e=png\&b=fefefe) ## 13.总结这段代码展示了一个基于Spring Boot和MyBatis Plus的后端服务的典型架构，主要涉及到以下方面： ### 1. 项目依赖及配置： - 使用了Spring Boot框架，简化了项目的配置和搭建。 - 数据库连接使用了`mysql-connector-j`，数据源使用了`druid`，MyBatis Plus作为持久层框架。 - 使用了`lombok`简化实体类的代码。 - 引入了一些辅助工具库，如`hutool`和`mybatis-plus-join-core`，用于增强开发效率和提供一些扩展功能。 ### 2. MyBatis Plus分页实现： - 配置了MyBatis Plus的分页插件，通过`PaginationInnerInterceptor`实现分页功能。 - 自定义了`MybatisPlusConfig`类，配置了分页插件，并将其注入到Spring容器中。 ### 3. 数据库实体和分页请求视图对象： - 存在`Student`实体类，用于映射数据库中的学生表。 - 定义了`PageParam`类，作为分页查询的请求参数对象，包含了页码、每页条数等信息。 ### 4. 数据库操作接口和实现： - 存在`BaseMapperX`接口，继承了MyBatis Plus的`BaseMapper`和自定义的`MPJBaseMapper`，提供了一系列对数据库操作的方法，包括分页查询、条件查询等。 - `StudentMapper`接口继承了`BaseMapperX`，用于学生表的数据库操作。 - `StudentServiceImpl`实现了`IStudentService`接口，提供了具体的业务逻辑，包括分页查询学生列表。 ### 5. 自定义工具类和扩展： - 存在`LambdaQueryWrapperX`类，对MyBatis Plus的`LambdaQueryWrapper`进行了拓展，增加了一系列条件拼接的方法，根据条件值的存在性来动态拼接查询条件。 ### 6. 分页查询方法： - 在`IStudentService`接口中定义了一个默认方法`getStudentList`，接受一个`StudentPageReqVO`对象作为查询条件，通过调用`selectPage`方法实现学生列表的分页查询。 ### 总体评价： - 代码结构清晰，遵循了一定的分层架构，将持久层、业务层和控制层分离。 - 使用了Spring Boot和MyBatis Plus等现代化框架，简化了开发流程，提高了开发效率。 - 引入了自定义工具类和扩展，使得代码更加灵活，可扩展性较好。 - 分页查询方法采用了默认方法的方式，提高了接口的兼容性。总体而言，这个项目展示了一个典型的后端服务架构，具备良好的可读性、可维护性和可扩展性。