一文读懂：MybatisPlus从入门到进阶
快速入门
简介
在项目开发中，Mybatis已经为我们简化了代码编写。
但是我们仍需要编写很多单表CURD语句，MybatisPlus可以进一步简化Mybatis。
MybatisPlus官方文档：https://www.baomidou.com/，感谢苞米豆和黑马程序员。
MybatisPlus无侵入的提供了代码生成、自动分页、逻辑删除、自动填充等功能。
需要注意，MybatisPlus提高了单表查询开发效率，复杂的多表查询还需要结合Mybatis配置文件使用。
引入依赖
MybatisPlus提供了starter，包含Mybatis以及MybatisPlus的相关依赖：
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.5.3.1version>
dependency>
定义Mapper
为了简化单表CURD，MybatisPlus提供了BaseMapper接口。
BaseMapper实现了单表CURD，我们定义的Mapper接口只需要继承它：
package com.test.mp.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.mp.domain.po.User;
public interface UserMapper extends BaseMapper<User> {
}
这样，对于单表简单的CURD，我们不再需要编写SQL语句。
原理
MybatisPlus是如何判断我们查询的表和字段名呢？
MybatisPlus通过扫描实体类，基于反射获取实体类信息作为数据库表信息。
在定义Mapper继承BaseMapper
这个泛型就是数据库对应的POJO，MybatisPlus就是根据这个泛型进行推断生成SQL：
- 把POJO的类名驼峰转下划线作为表名
- 把POJO所有变量名驼峰转下划线作为字段名，并根据变量类型推断字段类型
- 把名为id的字段作为主键
常用注解
@TableName
如果POJO类名不符合约定，与表明不一致。
可以使用@TableName注解指定表名。
例如，POJO类名为UserMapper，实际的数据库表名为tb_user：
package com.test.mp.domain.po;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@TableName("tb_user")
public class User {
private Long id;
private String username;
private String password;
private String phone;
private String info;
private Integer status;
private Integer balance;
private LocalDateTime createTime;
private LocalDateTime updateTime;
}
@TableId
如果POJO类里没有名为id的成员变量，或者主键不是id。
可以使用@TableId注解指定主键成员变量，它有2个属性：
- value：数据库主键字段名（成员变量名和数据库字段名不一致时使用）
- type：主键的策略（默认为雪花算法，常用IdType.NONE）
其中，常用的type有如下三种：
- AUTO：数据库自增长，即AUTO_INCREMENT。
- INPUT：通过set方法自行输入。
- ASSIGN_ID：分配ID，接口identifierGenerator的方法nextId来生成id，默认实现类为DefaultIdentifierGenerator雪花算法。
（通常情况下，我们按照MybatisPlus规范定义POJO和数据库字段，因此只需要指定@TableId(type=IdType.AUTO)
例如：
package com.test.mp.domain.po;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@TableName("tb_user")
public class User {
@TableId(value="uid", type=IdType.AUTO)
private Long uid;
private String username;
private String password;
private String phone;
private String info;
private Integer status;
private Integer balance;
private LocalDateTime createTime;
private LocalDateTime updateTime;
}
@TableField
和TableId的用途一样，只不过不指定主键。只指定成员变量和数据库字段名对应关系。
除此之外，有3种特殊情况也需要用到@TableField注解：
- 成员变量是Boolean类型且以is开头，如isMarried。MybatisPlus通过反射获取成员变量名时会去掉is，得到Married。
- 成员变量名和sql关键字冲突，如order。
- 成员变量不是数据库字段。
因此，一般不建议成员变量使用is开头或与sql关键字冲突。如果非要这么使用，需要用@TableField注解指定和数据库字段的映射关系。
例如：
package com.itheima.mp.domain.po;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class User {
private Long id;
private String username;
private String password;
@TableField("`is_married`")
private boolean isMarried;
@TableField("`order`")
private Integer orderr;
@TableField(exist=false)
private Integer notInTable;
}
常见配置
MybatisPlus的配置项继承了Mybatis原生配置，并在此基础上新增自己的配置。如：
mybatis-plus:
type-aliases-package: com.test.mp.domain.pojo # 别名扫描包
mapper-locations: "classpath*:/mapper/**/*.xml" # Mapper.xml文件地址，默认值
configuration:
map-underscore-to-camel-case: true # 是否开启下划线和驼峰的映射
cache-enabled: false # 是否开启二级缓存
global-config:
db-config:
id-type: assign_id # id为雪花算法生成
update-strategy: not_null # 更新策略：只更新非空字段
核心功能
MybatisPlus为我们提供的CURD是根据id为条件的，如果我们需要复杂条件的CURD，需要用到一些核心功能。
条件构造器
在MybatisPlus提供的BaseMapper接口按ctrl+f12，发现很多方法的参数有Wrapper类型：
选中代码中的Wrapper类名按ctrl+h显示所有子类，右击Wrapper选择Diagrams -> Show Diagrams Popup。
然后右击Wrapper选择Show Implementations查看继承关系图，这些Wrapper就是条件构造器：
QueryWrapper
QueryWrapper常用于构建select、delete、update的where条件部分。
我们以QueryWrapper为例，查询名字中带o的且存款大于等于1000元的用户的id、username、info和balance字段：
SELECT id, username, info, balance From user WHERE username LIKE ? AND balance >= ?;
@Test
void testQueryWrapper() {
// 1.构建查询条件
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.select("id", "username", "info", "balance")
.like("username", "o")
.ge("balance", 1000);
// 2.查询
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
再展示另外一个例子，更新用户名为jack的用户的余额为2000：
UPDATE user SET balance = 2000 WHERE (username = "jack");
@Test
void testUpdateByQueryWrapper() {
// 1.要更新的数据
User user = new User();
user.setBalance(2000);
// 2.更新的条件
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.eq("username", "jack");
// 3.执行更新
userMapper.update(user, wrapper);
}
UpdateWrapper
UpdateWrapper通常只有在set语句比较特殊才使用。
我们以UpdateWrapper为例，更新id为1, 2, 4的用户的余额，扣200。
UPDATE user SET balance = balance - 200 WHERE id in (1, 2, 4);
@Test
void testUpdateByWrapper() {
// 1. 要更新的id集合
List<Long> ids = List.of(1L, 2L, 4L);
// 2. 设置set语句并构建更新条件
UpdateWrapper<User> wrapper = new UpdateWrapper<User>()
.setSql("balance = balance -200")
.in("id", ids);
// 3. 更新
userMapper.update(null, wrapper);
}
LambdaWrapper
LambdaWrapper包括：LambdaQueryWrapper和LambdaUpdateWrapper。
我们以LambdaQueryWrapper为例，前面使用QueryWrapper时，我们使用了字符串硬编码。
为了避免硬编码，MybatisPlus推荐使用LambdaQueryWrapper，通过lambda方法引用来调用：
@Test
void testLambdaQueryWrapper() {
// 1.构建查询条件
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<User>()
.select(User::getId, User::getUsername, User::getInfo, User::getBalance)
.like(User::getUsername, "o")
.ge(User::getBalance, 1000);
// 2.查询
List<User> users = userMapper.selectList(wrapper);
users.forEach(System.out::println);
}
自定义SQL
在前面的UpdateWrapper中，我们将set更新的sql语句写在了业务层代码中，不符合实际开发低耦合的规范。
比较常见的用法是用MybatisPlus的Wrapper来构建复杂的Where条件，然后自己定义SQL语句中剩下的部分。
（对于多表操作，也可以用这种方法构建Where条件，然后编写剩余部分的SQL语句）
例如，我们将id在指定范围内的用户的余额扣减指定值：
-
基于Wrapper构建where条件：
@Test void testCustomSqlUpdate() { // 1.更新条件 List<Long> ids = List.of(1L, 2L, 4L); int amount = 200; // 2.定义条件 LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<User>() .in(User::getId, ids); // 3.调用自定义SQL方法 userMapper.updateBanlanceByIds(wrapper, amount); } -
在mapper方法参数中用Param注解声明wrapper变量名称，必须是ew：
// 注解声明的Wrapper的变量名称必须是ew，也可以使用常量值Constants.WRAPPER public interface UserMapper extends BaseMapper<User> { void updateBanlanceByIds(@Param(Constants.WRAPPER) LambdaQueryWrapper<User> wrapper, @Param("amount") int amount); } -
自定义SQL，并使用传递下来的Wrapper条件：
<update id="updateBanlanceByIds"> UPDATE user SET balance = balance - #{amount} ${ew.customSqlSegment} update>
Service接口
原理
MybatisPlus已经帮我们简化了单表CURD操作，但我们还需要写Service层代码。
为了进一步简化，MybatisPlus为我们提供了IService接口，这个接口提供了简单CURD的Service抽象方法。
我们定义的UserService接口可以继承IService，IService包含简单CURD的抽象方法。但是会出现一个问题。
IService接口非常多，UserServiceImpl在实现接口时需要实现全部方法，如下图所示：
为了解决这个问题，MybatisPlus又为我们提供了ServiceImpl实现Iservice所有的抽象方法，我们的UserServiceImpl只需要继承它即可：
基本用法
下面通过一个例子来演示IService：
-
定义IUserService接口继承IService接口，并指定泛型为POJO类：
package com.test.mp.service; import com.baomidou.mybatisplus.extension.service.IService; import com.test.mp.domain.po.User; public interface IUserService extends IService<User> { } -
定义IUserServiceImpl类实现IUserService接口，然后继承ServiceImpl类并指定Mapper和POJO的泛型：
package com.test.mp.service.impl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.test.mp.domain.po.User; import com.test.mp.mapper.UserMapper; import com.test.mp.service.IUserService; import org.springframework.stereotype.Service; @Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService { } -
测试，简单CURD无需编写Service和Mapper代码：
@SpringBootTest class IUserServiceTest { @Autowired private IUserService userService; @Test void testSaveUser() { User user = new User(); user.setUsername("Test"); user.setPassword("123456"); user.setPhone("18888888888"); user.setBalance(200); user.setCreateTime(LocalDateTime.now()); user.setUpdateTime(LocalDateTime.now()); userService.save(user); } @Test void testQuery() { List<User> users = userService.listByIds(List.of(1L, 2L, 4L)); users.forEach(System.out::println); } }
基础用法
下面以一个案例来演示MybatisPlus的强大的功能：实现对用户表的新增、删除、查询。
-
为了方便接口调试，我们引入Swagger相关依赖：
<dependency> <groupId>com.github.xiaoymingroupId> <artifactId>knife4j-openapi2-spring-boot-starterartifactId> <version>4.1.0version> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-webartifactId> dependency> -
然后在Controller编写，对于简单的增、删、查，IService已经为我们封装好了相关方法。
我们不需要再编写Service和Mapper代码就可以实现这些功能：
@Api(tags = "用户管理接口") @RequestMapping("/users") @RestController @RequiredArgsConstructor public class UserController { // @RequiredArgsConstructor注解通过构造函数给userService赋值 private final IUserService userService; @ApiOperation("新增用户接口") @PostMapping public void saveUser(@RequestBody UserFormDTO userDTO) { User user = BeanUtil.copyProperties(userDTO, User.class); userService.save(user); } @ApiOperation("删除用户接口") @DeleteMapping("/{id}") public void deleteUser(@ApiParam("用户id") @PathVariable("id") Long id) { userService.removeById(id); } @ApiOperation("根据id查询用户接口") @GetMapping("/{id}") public UserVO queryUserById(@ApiParam("用户id") @PathVariable("id") Long id) { User user = userService.getById(id); return BeanUtil.copyProperties(user, UserVO.class); } @ApiOperation("根据id批量查询用户接口") @GetMapping public List<UserVO> queryUserByIds(@ApiParam("用户id") @RequestParam("ids") List<Long> ids) { List<User> users = userService.listByIds(ids); return BeanUtil.copyToList(users, UserVO.class); } }
自定义用法
对于一些比较复杂的查询，还需要我们自定义Service和Mapper代码。
以这样一个案例为例：扣减用户余额。
-
由于不是常规查询，因此我们在Controller编写代码调用自定义的Service方法。
@Api(tags = "用户管理接口") @RequestMapping("/users") @RestController @RequiredArgsConstructor public class UserController { // @RequiredArgsConstructor注解通过构造函数给userService赋值 private final IUserService userService; @ApiOperation("扣减用户余额接口") @GetMapping("/{id}/deduction/{money}") public void deductMoneyById(@ApiParam("用户id") @PathVariable("id") Long id, @ApiParam("扣减的金额") @PathVariable("money") Integer money) { userService.deductBalance(id, money); } } -
然后在ServiceImpl实现自定义的方法。首先判断是否合法，然后调用Mapper中自定义的方法：
@Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService { @Override public void deductBalance(Long id, Integer money) { User user = getById(id); if (user == null || user.getStatus() == 2) { throw new RuntimeException("用户状态异常！"); } if (user.getBalance() < money) { throw new RuntimeException("用户余额不足！"); } baseMapper.deductBalance(id, money); } } -
然后在Mapper中定义SQL语句，复杂的可以使用Wrapper，简单的可以使用注解或xml：
public interface UserMapper extends BaseMapper<User> { @Update("UPDATE user SET balance = balance - #{money} WHERE id = #{id}") void deductBalance(@Param("id") Long id, @Param("money") Integer money); }
Lambda查询
对于条件查询，以往我们需要写xml判断某个参数是否为空。MybatisPlus也为我们提供了简便用法Lambda以省略mapper编写。
现在，我们以这样一个案例为例：根据name、status、minBalance、maxBalance模糊查询用户。
-
在Controller编写代码调用Service层自定义方法：
@Api(tags = "用户管理接口") @RequestMapping("/users") @RestController @RequiredArgsConstructor public class UserController { private final IUserService userService; @ApiOperation("根据复杂条件查询用户接口") @GetMapping("/list") public List<UserVO> queryUsers(UserQuery query) { List<User> users = userService.queryUsers(query.getName(), query.getStatus(), query.getMinBalance(), query.getMaxBalance()); return BeanUtil.copyToList(users, UserVO.class); } } -
在ServiceImpl定义方法，可以通过查询方法的链式调用进行查询。
对于like、eq、gt、lt等方法，如果传入三个参数，第一个参数为condition。
最后通过one、list、page、count等方法获取查询结果。
@Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService { @Override public List<User> queryUsers(String name, Integer status, Integer minBalance, Integer maxBalance) { return lambdaQuery() .like(name != null, User::getUsername, name) .eq(status != null, User::getStatus, status) .gt(minBalance != null, User::getBalance, minBalance) .lt(maxBalance != null, User::getBalance, maxBalance) .list(); } }
Lambda更新
我们以这样一个需求为例：根据id扣减用户余额，完成对用户状态、余额校验。如果扣减后余额为0，修改status为2。
前面我们已经完成了deductBalance业务流程，现在我们只需要修改service层对mapper调用为lambda即可。无需再写mapper代码。
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
public void deductBalance(Long id, Integer money) {
User user = getById(id);
if (user == null || user.getStatus() == 2) {
throw new RuntimeException("用户状态异常！");
}
if (user.getBalance() < money) {
throw new RuntimeException("用户余额不足！");
}
int remainBalance = user.getBalance() - money;
lambdaUpdate()
.set(User::getBalance, remainBalance)
.set(remainBalance == 0, User::getStatus, 2)
.eq(User::getId, id)
.update();
}
}
但是这里还存在一个问题，如果有多个线程执行这个方法。如：ThreadA(扣100)、ThreadB（扣100）。
若同时执行到remainBalance，最终得到的remainBlance相同。最终两个线程只有一个生效。
因此，这里需要加线程锁。可以是乐观锁，也可以是悲观锁。
我们这里采用乐观锁（先比较再更新），在执行update前先使用.eq(User::getBalance, user.getBalance())判断。
如果条件不成立，说明已经有其它线程对Balance进行修改。当前update就失败了。
@Service
@Transactional
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
@Override
public void deductBalance(Long id, Integer money) {
User user = getById(id);
if (user == null || user.getStatus() == 2) {
throw new RuntimeException("用户状态异常！");
}
if (user.getBalance() < money) {
throw new RuntimeException("用户余额不足！");
}
int remainBalance = user.getBalance() - money;
lambdaUpdate()
.set(User::getBalance, remainBalance)
.set(remainBalance == 0, User::getStatus, 2)
.eq(User::getId, id)
.eq(User::getBalance, user.getBalance())
.update();
}
}
拓展功能
代码生成
前面，我们根据数据库表定义POJO、Mapper接口、Service接口、ServiceImpl和Controller。
对于不同的数据库表，定义的模板文件是相同的，区别就在于POJO字段名和文件的接口名及类名。
MybatisPlus为我们提供了代码生成器，可以根据数据库表一键生成这些文件：
-
安装MyabtisPlus插件：
-
然后打开菜单栏->Other->Config Database配置数据库信息：
jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai -
然后再次打开菜单栏->Other->Code Generator：
-
点击右下角code generatro即可生成相应的文件：
静态工具
IService接口提供的方法都是非静态方法，不同Service之间相互调用可能会导致循环依赖。
MybatisPlus为我们提供了DB静态工具，其中的方法为静态方法，避免了循环依赖问题，DB调用时需要传入Class参数。
第一个案例：根据id查询用户并查询用户的所有地址。
@Override
public UserVO queryUserAndAddressById(Long id) {
User user = getById(id);
if (user == null || user.getStatus() == 2) {
throw new RuntimeException("用户状态异常！");
}
List<Address> addresses = Db.lambdaQuery(Address.class)
.eq(Address::getUserId, id)
.list();
UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
if (CollUtil.isNotEmpty(addresses)) {
userVO.setAddresses(BeanUtil.copyToList(addresses, AddressVO.class));
}
return userVO;
}
第二个案例：批量查询用户并查询用户的所有地址。
@Override
public List<UserVO> queryUserAndAddressByIds(List<Long> ids) {
// 根据id查询user
List<User> users = listByIds(ids);
if (CollUtil.isEmpty(users)) {
return Collections.emptyList();
}
// 获取用户id集合
List<Long> userIds = users.stream().map(User::getId).collect(Collectors.toList());
// 根据id查询地址
List<Address> addresses = Db.lambdaQuery(Address.class)
.in(Address::getUserId, userIds)
.list();
// 转换地址为VO
List<AddressVO> addressVOList = BeanUtil.copyToList(addresses, AddressVO.class);
// 分类整理地址集合：相同用户的放入一个集合
Map<Long, List<AddressVO>> addressMap = new HashMap<>(0);
if (CollUtil.isNotEmpty(addressVOList)) {
addressMap = addressVOList.stream().collect(Collectors.groupingBy(AddressVO::getUserId));
}
// 转换VO返回
List<UserVO> list = new ArrayList<>(users.size());
for (User user : users) {
UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
list.add(userVO);
userVO.setAddresses(addressMap.get(user.getId()));
}
return list;
}
逻辑删除
日常生活中，我们在网站上执行删除操作，实际上是软删除。只是在数据库中将数据标记为删除，并不是真正的从数据库中删除。
具体实现方法是在表中添加一个字段标记数据是否被删除，当删除数据时把标记置为1，查询时只查询标记为0的数据。
例如：逻辑删除字段为deleted
查询操作：
SELECT * FROM user WHERE deleted = 0;
删除操作：
UPDATE user SET deleted = 1 WHERE id = 1 AND deleted = 0;
MybatisPlus提供了逻辑删除功能，无需改变方法调用方式，而是在底层帮我们自动修改CURD语句。
我们需要做的就是在application.yaml文件中配置逻辑删除的字段名称和值即可。
mybatis-plus:
global-config:
db-config:
logic-delete-field: deleted # 全局逻辑删除的实体字段名，字段类型可以是boolean、integer
logic-delete-value: 1 # 逻辑删除值（默认为1）
logic-not-delete-value: 0 # 逻辑未删除值（默认为0）
枚举处理器
如果POJO类中有一个枚举类型的成员变量，如：
@Getter
public enum UserStatus {
NORMAL(1, "正常"),
FREEZE(2, "冻结")
;
private final int value;
private final String desc;
UserStatus(int value, String desc) {
this.value = value;
this.desc = desc;
}
}
@Data
public class User {
@TableId(type = IdType.AUTO)
private Long id;
private String username;
private String password;
private String phone;
private String info;
private Integer status;
private Integer balance;
private UserStatus status;
private LocalDateTime createTime;
private LocalDateTime updateTime;
}
对于status成员变量，数据库字段的类型是INT，POJO的类型的enum。
Mybatis有一个TypeHandler接口，它可以实现数据库和Java类型的转换。但它不能将Enum类型和数据库的类型进行转换。
MybatisPlus提供了MybatisEnumTypeHandler处理器，以实现Enum类型和数据库类的转换，用法如下：
-
在application.yml配置：
mybatis-plus: configuration: default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler -
在enum类上加@EnumValue注解：
@Getter public enum UserStatus { NORMAL(1, "正常"), FREEZE(2, "冻结") ; @EnumValue private final int value; private final String desc; UserStatus(int value, String desc) { this.value = value; this.desc = desc; } }
此时，再次查询会默认返回枚举项，如：NORMAL、FREEZE。
如果想返回value或desc，可以在对应的成员变量上加@JsonValue注解。
JSON处理器
数据库字段有一个冷门的类型：json。在Java对应的POJO中我们一般用String成员变量映射这个字段。
Mybatis也为我们提供了自动从数据库的json转换为Java的字符串的功能。如：
但是在Java中String类型不能直接访问json成员，为了解决这个问题，我们可以根据Json定义一个实体类：
为了实现实体类和数据库json类型的转换，MybatisPlus提供了一个Json类型处理器。用法如下：
在对应的字段的@TableFirld注解上加入typeHandler = JacksonTypeHandler.class属性。
但是这样需要在所有json字段都加注解，非常繁琐。我们可以采用另一种方法：
在@TableName注解上加入autoResultMap = true属性。
插件功能
MybatisPlus提供的内置拦截器有：多租户插件、动态表名插件、分页插件、乐观锁插件、SQL性能规范插件等。
比较常用的插件就是分页插件，之前我们通过pageHelper实现分页，下面将介绍MybatisPlus分页插件的用法。
分页插件
首先，要在配置类中注册MybatisPlus的核心插件，同时添加分页插件：
@Configuration
public class MybatisConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
// 初始化核心插件
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 添加分页插件
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return interceptor;
}
}
然后编写分页查询代码：
@Test
void testPageQuery() {
// 1.分页查询，new Page()的两个参数分别是：页码、每页大小
Page<User> p = userService.page(new Page<>(2, 2));
// 2.总条数
System.out.println("total = " + p.getTotal());
// 3.总页数
System.out.println("pages = " + p.getPages());
// 4.数据
List<User> records = p.getRecords();
records.forEach(System.out::println);
}
也支持排序：
int pageNo = 1, pageSize = 5;
// 分页参数
Page<User> page = Page.of(pageNo, pageSize);
// 排序参数, 通过OrderItem来指定
page.addOrder(new OrderItem("balance", false));
userService.page(page);
通用分页实体
很多业务都有分页查询需求，因此我们可以为分页查询定义一个通用的实体PageQuery：
@Data
public class PageQuery {
private Integer pageNo;
private Integer pageSize;
private String sortBy;
private Boolean isAsc;
public <T> Page<T> toMpPage(OrderItem ... orders){
// 1.分页条件
Page<T> p = Page.of(pageNo, pageSize);
// 2.排序条件
// 2.1.先看前端有没有传排序字段
if (sortBy != null) {
p.addOrder(new OrderItem(sortBy, isAsc));
return p;
}
// 2.2.再看有没有手动指定排序字段
if(orders != null){
p.addOrder(orders);
}
return p;
}
public <T> Page<T> toMpPage(String defaultSortBy, boolean isAsc){
return this.toMpPage(new OrderItem(defaultSortBy, isAsc));
}
public <T> Page<T> toMpPageDefaultSortByCreateTimeDesc() {
return toMpPage("create_time", false);
}
public <T> Page<T> toMpPageDefaultSortByUpdateTimeDesc() {
return toMpPage("update_time", false);
}
}
然后定义一个返回结果的通用实体PageDTO：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageDTO<V> {
private Long total;
private Long pages;
private List<V> list;
/**
* 返回空分页结果
* @param p MybatisPlus的分页结果
* @param 目标VO类型
* @param 原始PO类型
* @return VO的分页对象
*/
public static <V, P> PageDTO<V> empty(Page<P> p){
return new PageDTO<>(p.getTotal(), p.getPages(), Collections.emptyList());
}
/**
* 将MybatisPlus分页结果转为 VO分页结果
* @param p MybatisPlus的分页结果
* @param voClass 目标VO类型的字节码
* @param 目标VO类型
* @param 原始PO类型
* @return VO的分页对象
*/
public static <V, P> PageDTO<V> of(Page<P> p, Class<V> voClass) {
// 1.非空校验
List<P> records = p.getRecords();
if (records == null || records.size() <= 0) {
// 无数据，返回空结果
return empty(p);
}
// 2.数据转换
List<V> vos = BeanUtil.copyToList(records, voClass);
// 3.封装返回
return new PageDTO<>(p.getTotal(), p.getPages(), vos);
}
/**
* 将MybatisPlus分页结果转为 VO分页结果，允许用户自定义PO到VO的转换方式
* @param p MybatisPlus的分页结果
* @param convertor PO到VO的转换函数
* @param 目标VO类型
* @param 原始PO类型
* @return VO的分页对象
*/
public static <V, P> PageDTO<V> of(Page<P> p, Function<P, V> convertor) {
// 1.非空校验
List<P> records = p.getRecords();
if (records == null || records.size() <= 0) {
// 无数据，返回空结果
return empty(p);
}
// 2.数据转换
List<V> vos = records.stream().map(convertor).collect(Collectors.toList());
// 3.封装返回
return new PageDTO<>(p.getTotal(), p.getPages(), vos);
}
}
以后业务需要的分页查询和分页结果可以继承这两个通用实体。