MyBatis-Plus 学习笔记

Preparing: INSERT INTO user ( username, password, phone, info, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ? )
Parameters: user_1, 123, 18688190001, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_2, 123, 18688190002, "", 2000, 2023-07-01, 2023-07-01
Parameters: user_3, 123, 18688190003, "", 2000, 2023-07-01, 2023-07-01

MySQL的客户端连接参数中有这样的一个参数：rewriteBatchedStatements。顾名思义，就是重写批处理的statement语句。参考文档：MySQL :: Connectors and APIs Manual :: 3.5.3.13 Performance Extensions 的 rewriteBatchedStatements

这个参数的默认值是false，我们需要修改连接参数，将其配置为true

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/mp?...&rewriteBatchedStatements=true

耗时：4117ms

五、扩展功能

5.1 代码生成

新款 IDEA 2024 使用方法：

① 工具 --> Config Database

如果测试链接还是连不上，需要加&useSSL=false

② 工具 --> Code Generator

直接点 Code Generate 没反应的，应该先点 check field 然后点 OK，然后再生成

5.2 静态工具

有的时候Service之间也会相互调用，如果使用@Autowired相互注入，就会产生循环依赖问题。为了避免这种情况，MybatisPlus提供一个静态工具类：Db，其中的一些静态方法与IService中方法签名基本一致，也可以帮助我们实现CRUD功能。使用的时候有些方法需要提供字节码类（SomeClassName.class）。

当然也可以直接去使用mapper，能不用Service就不用。

—— 摘自黑马 day01-MybatisPlus - 飞书云文档

5.2.1 案例——静态工具查询

需求介绍：
① 改造根据id查询用户的接口，查询用户的同时，给出用户对应的所有地址；
② 改造根据id批量查询用户的接口，查询用户的同时，查询出用户对应的所有地址；
③ 实现根据用户id查询收货地址功能，需要验证用户状态，冻结用户抛出异常。

① 改造根据id查询用户的接口，查询用户的同时，给出用户对应的所有地址。

AddressVO 实体类：

package com.itheima.mp.domain.vo;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @author 虎哥
 * @since 2023-07-01
 */
@Data
@ApiModel(description = "收货地址VO")
public class AddressVO{

    @ApiModelProperty("id")
    private Long id;

    @ApiModelProperty("用户ID")
    private Long userId;

    @ApiModelProperty("省")
    private String province;

    @ApiModelProperty("市")
    private String city;

    @ApiModelProperty("县/区")
    private String town;

    @ApiModelProperty("手机")
    private String mobile;

    @ApiModelProperty("详细地址")
    private String street;

    @ApiModelProperty("联系人")
    private String contact;

    @ApiModelProperty("是否是默认 1默认 0否")
    private Boolean isDefault;

    @ApiModelProperty("备注")
    private String notes;
}

UserVO 加字段（无需加到User实体类，也就是说User类中不含address）：

@ApiModelProperty("用户收货地址列表")
private List<AddressVO> addresses;

UserController 直接调 UserService

@ApiOperation("根据id查询用户（含地址）")
@GetMapping("/{id}")
public UserVO getUserById(@ApiParam("用户id") @PathVariable("id") Long id) {
    return userService.queryUserAndAddressById(id);
}

IUserService 添加对应的方法声明：

UserVO queryUserAndAddressById(Long id);

UserServiceImpl 实现对应方法：

@Override
public UserVO queryUserAndAddressById(Long id) {
    // 1、查询用户
    User user = getById(id);
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 2、查询地址
    List<Address> addresses = Db.lambdaQuery(Address.class)
            .eq(Address::getUserId, id).list();
    // 3、封装 VO
    // 3.1 转 User 的 PO 为 VO
    UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
    // 3.2 转 Address 的 PO 为 VO
    if (!CollUtil.isEmpty(addresses)) {
        userVO.setAddresses(BeanUtil.copyToList(addresses, AddressVO.class));
    }
    return userVO;
}

② 改造根据id批量查询用户的接口，查询用户的同时，查询出用户对应的所有地址；

UserController：

@ApiOperation("用id批量查用户（含地址）")
@GetMapping
public List<UserVO> listUsersByIds(
        @ApiParam("用户id列表") @RequestParam("ids") List<Long> ids) {
    return userService.queryUserAndAddressByIds(ids);
}

 IUserService 添加对应的方法声明：

List<UserVO> queryUserAndAddressByIds(List<Long> ids);

 UserServiceImpl 实现对应方法：

场景：要查多个User，每个User又对应多个地址

相当好的案例，之前不知道如何优雅地处理这种情况，建议熟读并背诵 🤣

@Override
public List<UserVO> queryUserAndAddressByIds(List<Long> ids) {
    // 1、查询用户
    List<User> users = listByIds(ids);
    if (CollUtil.isEmpty(users)) {
        return Collections.emptyList();
    }
    // 2、查询地址
    // 2.1 获取用户id集合
    List<Long> userIds = users.stream().map(User::getId).collect(Collectors.toList());
    // 2.2 根据用户id查询地址
    List<Address> addresses = Db.lambdaQuery(Address.class)
            .in(Address::getUserId, userIds).list();
    // 2.3 转换地址 VO
    List<AddressVO> addressVOList = BeanUtil.copyToList(addresses, AddressVO.class);
    // 2.4 对用户地址集合分组，相同用户的放入一个集合中
    Map<Long, List<AddressVO>> addressMap = new HashMap<>(0);
    if (CollUtil.isNotEmpty(addressVOList)) {
        addressMap = addressVOList
                .stream().collect(Collectors.groupingBy(AddressVO::getUserId));
    }
    // 3、转 VO 返回
    List<UserVO> list = new ArrayList<>(users.size());
    for (User user : users) {
        // 3.1 转 User 的 PO 为 VO
        UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
        // 3.2 转换 Address 的 PO 为 VO
        userVO.setAddresses(addressMap.get(user.getId()));
        // 3.3 添加到集合中
        list.add(userVO);
    }
    return list;
}

5.3 逻辑删除

注意：只有MybatisPlus生成的SQL语句才支持自动的逻辑删除，自定义SQL需要自己手动处理逻辑删除。

MybatisPlus提供了对逻辑删除的支持，无需改变代码中调用CRUD的方式，只需要修改配置，即可为所有的操作自动拼接：

-- 用 deleted = 0 表示未删除
WHERE deleted = 0

5.3.1 配置步骤

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: deleted # 全局逻辑删除的字段名(类型为boolean、integer)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

-- 添加逻辑删除字段的SQL
alter table address add deleted bit default b'0' null comment '逻辑删除';

5.3.2 编辑测试类

package com.itheima.mp.service;

import com.itheima.mp.domain.po.Address;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class IAddressServiceTest {

    @Autowired
    private IAddressService addressService;

    @Test
    void testLogicDelete() {
        // 1、删除
        addressService.removeById(59L);
        // 2、查询
        Address address = addressService.getById(59L);
        System.out.println("address = " + address);
    }
}

运行结果：

==>  Preparing: UPDATE address SET deleted=1 WHERE id=? AND deleted=0
==> Parameters: 59(Long)
<==    Updates: 1
==>  Preparing: SELECT id,user_id,province,city,town,mobile,street,contact,is_default,notes,deleted FROM address WHERE id=? AND deleted=0
==> Parameters: 59(Long)
<==      Total: 0
address = null

5.4 枚举处理器

掌握Java中的枚举类型，与数据库字段之间的相互转换

User 类中有一个用户状态字段：

/**
 * 使用状态（1正常 2冻结）
 */
private Integer status;

5.4.1 创建枚举类

package com.itheima.mp.enums;

import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.Getter;

@Getter
public enum UserStatus {
    NORMAL(1, "正常"),
    FROZEN(2, "冻结");

    @EnumValue  // 告诉 mybatis-plus 这个字段是枚举值
    private final int value;
    private final String desc;

    UserStatus(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }
}

5.4.2 配置枚举处理器

配置枚举处理器类型为：MybatisEnumTypeHandler

mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler

5.4.3 修改User和UserVO

/**
 * 使用状态（1正常 2冻结）
 */
private Integer status;  -->  private UserStatus status;

public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService  {
    @Override
    @Transactional
    public void deductBalance(Long id, Integer money) {
        ...
        [-] if (user == null || user.getStatus() == 2) {
        [+] if (user == null || user.getStatus() == UserStatus.FROZEN) {
        ...
    }
}

其余的魔法值也都改成 UserStatus.NORMAL 或者 UserStatus.FROZEN

前端查询到的结果：

{
  "id": 1,
  "username": "Jack",
  "info": "{\"age\": 20, \"intro\": \"佛系青年\", \"gender\": \"male\"}",
  "status": "NORMAL",
  "balance": 2400,
  "addresses": [ ]
}

可以看到默认返回的是枚举变量名，而非枚举值！

SpringMVC 处理 JSON 默认使用的是 Jackson 包，配置方式如下：

@Getter
public enum UserStatus {
    NORMAL(1, "正常"),
    FROZEN(2, "冻结");

    @EnumValue  // 告诉 mybatis-plus 这个字段是枚举值
[+] @JsonValue 
    private final int value;
    private final String desc;
    ...
}

@JsonValue 加在 value 上，返回的就是value值（1或2）；加在 desc 上，返回的就是"正常"或"冻结"

5.5 JSON处理器

用于处理对象嵌套对象查询的自动映射，例如User类有个UserInfo的属性🤠

数据库的user表中有一个info字段，是JSON类型，而User实体类中是String类型，这样一来，我们要读取info中的属性时就非常不方便。这时就可以使用JSON处理器

 5.5.1 定义UserInfo实体类

package com.itheima.mp.domain.po;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
// 提供了静态方法，用于创建对象
@AllArgsConstructor(staticName = "of")
public class UserInfo {
    private Integer age;
    private String intro;
    private String gender;
}

这里的 "of" 注解可以实现：UserInfo.of(24, "英文老师", "female") 直接创建对象

5.5.2 修改User和UserVO实体类

@Data
[+] @TableName(value = "user", autoResultMap = true)
public class User {
    ...
    [+] @TableField(typeHandler = JacksonTypeHandler.class)
    private UserInfo info;
    ...
}

六、插件功能

MybatisPlus提供了很多的插件功能，进一步拓展其功能。目前已有的插件有：

package com.itheima.mp.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusConfig {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        // 1、初始化核心插件
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 2、初始化分页插件
        PaginationInnerInterceptor pageInterceptor = 
                             new PaginationInnerInterceptor(DbType.MYSQL);
        pageInterceptor.setMaxLimit(1000L); // 单页最大数量
        // 3、添加分页插件到核心插件（如需使用其他插件，同理，new出来然后add即可）
        interceptor.addInnerInterceptor(pageInterceptor);
        return interceptor;
    }
}

...
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

@SpringBootTest
class IUserServiceTest {
    ...
    @Test
    void testPageQuery() {
        int pageNo = 1, pageSize = 2;
        // 1、准备分页条件
        // 1.1 分页条件
        Page<User> page = Page.of(pageNo, pageSize);
        // 1.2 排序条件
        // 条件1：余额排序
        page.addOrder(new OrderItem("balance", true));
        // 条件2：条件1满足后再按id排
        page.addOrder(new OrderItem("id", true));
        // 2、利用条件查询
        Page<User> resultPage = userService.page(page);
        // 3、解析查询结果（其实page和resultPage是同一个对象）
        long total = resultPage.getTotal();
        System.out.println("total = " + total);
        long pages = resultPage.getPages();
        System.out.println("pages = " + pages);
        List<User> records = resultPage.getRecords();
        records.forEach(System.out::println);
    }
}

运行结果：

==>  Preparing: SELECT COUNT(*) AS total FROM user
==> Parameters: 
<==      Total: 1
==>  Preparing: SELECT id, username, password, phone, info, status, balance, create_time, update_time FROM user ORDER BY balance ASC, id ASC LIMIT ?
==> Parameters: 2(Long)
<==      Total: 2
total = 5
pages = 3
User(id=5, username=Lucy, password=123, phone=18688990011, info=UserInfo(age=24, intro=英文老师, gender=female), status=NORMAL, balance=200, createTime=2025-05-06T10:40:04, updateTime=2025-05-06T10:40:04)
User(id=2, username=Rose, password=123, phone=13900112223, info=UserInfo(age=19, intro=青涩少女, gender=female), status=NORMAL, balance=800, createTime=2023-05-19T21:00:23, updateTime=2025-05-06T10:25:37)

6.2 通用分页实体

分页接口规范如下：

{
    "pageNo": 1,
    "pageSize": 5,
    "sortBy": "balance",
    "isAsc": false,
     ...
}

{
    "total": 100006,
    "pages": 50003,
    "list": [
        {
            "id": 1685100878975279298,
            "username": "user_9****",
             ...
        }, ...
    ]
}

6.2.1 新建查询条件实体

package com.itheima.mp.domain.query;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 用于接收前端的传参
 */
@ApiModel(description = "分页查询条件实体")
@Data
public class PageQuery {
    @ApiModelProperty("当前页码")
    private Integer pageNo;
    @ApiModelProperty("每页记录数")
    private Integer pageSize;
    @ApiModelProperty("排序字段")
    private String sortBy;
    @ApiModelProperty("是否正序")
    private Boolean isAsc;
}

6.2.2 用户查询实体扩展

package com.itheima.mp.domain.query;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * 用户查询条件实体
 */
[+] @EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(description = "用户查询条件实体")
public class UserQuery [+] extends PageQuery {
    @ApiModelProperty("用户名关键字")
    private String name;
    @ApiModelProperty("用户状态：1-正常，2-冻结")
    private Integer status;
    @ApiModelProperty("余额最小值")
    private Integer minBalance;
    @ApiModelProperty("余额最大值")
    private Integer maxBalance;
}

@EqualsAndHashCode(callSuper = true) 的核心价值：在继承场景中，确保子类的 equals() 和 hashCode() 方法能够正确比较父类字段，避免因字段遗漏导致的逻辑错误。例如以下示例：

@Data @EqualsAndHashCode(callSuper = false) // 默认值
class SubClass extends SuperClass {
    private String field;
}

@Data
class SuperClass {
    private int id;
}

如果 SubClass 的 equals() 和 hashCode() 未调用父类方法，则比较仅基于 field，而忽略 id。这可能导致两个 id 不同的 SubClass 对象被错误地认为相等。

6.2.3 请求结果实体

package com.itheima.mp.domain.dto;

import ...

/**
 *  分页查询结果
 */
@Data
@ApiModel(description = "分页查询结果")
public class PageResultDTO<T> {
    @ApiModelProperty("总记录数")
    private Long total;
    @ApiModelProperty("总页数")
    private Long pages;
    @ApiModelProperty("当前页数据")
    private List<T> list;
}

6.2.4 业务逻辑编写

public class UserController {
    ...
    @ApiOperation("根据条件分页查询用户")
    @GetMapping("/page")
    public List<UserVO> queryUsersPage(UserQuery query) {
        return userService.queryUsersWithPage(query);
    }
}

package com.itheima.mp.service.impl;

import ...

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService  {
    ...
    @Override
    public PageResultDTO<UserVO> queryUsersWithPage(UserQuery query) {
        Integer status = query.getStatus();
        String name = query.getName();
        // 1、构建分页条件
        // 1.1 分页条件
        Page<User> page = Page.of(query.getPageNo(), query.getPageSize());
        // 1.2 排序条件
        if (StrUtil.isNotBlank(query.getSortBy())) {
            // 如果条件不为空
            page.addOrder(new OrderItem(query.getSortBy(), query.getIsAsc()));
        } else {
            // 为空，则默认按时间排序（降序）
            page.addOrder(new OrderItem("update_time", false));
        }
        // 2、分页查询
        Page<User> pageResult = lambdaQuery()
                .like(name != null, User::getUsername, name)
                .eq(status != null, User::getStatus, status)
                .page(page);
        // 3、封装分页结果
        PageResultDTO<UserVO> dto = new PageResultDTO<>();
        List<User> result = pageResult.getRecords();
        if (CollUtil.isEmpty(result)) {
            dto.setList(Collections.emptyList());
            return dto;
        }
        dto.setPages(pageResult.getPages());
        dto.setTotal(pageResult.getTotal());
        dto.setList(BeanUtil.copyToList(result, UserVO.class));
        // 4、返回
        return dto;
    }
}

6.3 分页代码封装

6.3.1 改造分页查询实体

package com.itheima.mp.domain.query;

import ...

/**
 * 用于接收前端的传参
 */
@ApiModel(description = "分页查询条件实体")
@Data
public class PageQuery {
    @ApiModelProperty("当前页码")
    private Integer pageNo = 1;
    @ApiModelProperty("每页记录数")
    private Integer pageSize = 5;
    @ApiModelProperty("排序字段")
    private String sortBy;
    @ApiModelProperty("是否正序")
    private Boolean isAsc = true;

    public <T> Page<T> toMpPage(OrderItem ... items) {
        // 1、构建分页条件
        // 1.1 分页条件
        Page<T> page = Page.of(pageNo, pageSize);
        // 1.2 排序条件
        if (StrUtil.isNotBlank(sortBy)) {
            // 如果条件不为空
            page.addOrder(new OrderItem(sortBy, isAsc));
        } else if (items != null) {
            // 为空，则按传入OrderItem参数排序
            page.addOrder(items);
        }
        return page;
    }

    public <T> Page<T> toMpPage(String defaultSortBy, Boolean defaultAsc) {
        return toMpPage(new OrderItem(defaultSortBy, defaultAsc));
    }

    public <T> Page<T> toMpPageOrderByCreateTime() {
        return toMpPage(new OrderItem("create_time", false));
    }

    public <T> Page<T> toMpPageOrderByUpdateTime() {
        return toMpPage(new OrderItem("update_time", false));
    }
}

6.3.2 改造分页结果实体

方法1：PO转VO的逻辑写死为 BeanUtil.copyToList(数据结果集, 目标类)；
方法2：使用函数式接口，由调用者提供PO转VO的逻辑。

package com.itheima.mp.domain.dto;

import ...

/**
 *  分页查询结果
 */
@Data
@ApiModel(description = "分页查询结果")
public class PageResultDTO<T> {
    @ApiModelProperty("总记录数")
    private Long total;
    @ApiModelProperty("总页数")
    private Long pages;
    @ApiModelProperty("当前页数据")
    private List<T> list;

    public <PO, VO> PageResultDTO<VO> getPageResult(Page<PO> page, 
                                                    Class<VO> clazz) {
        // 3、封装分页结果
        PageResultDTO<VO> dto = new PageResultDTO<>();
        List<PO> result = page.getRecords();
        if (CollUtil.isEmpty(result)) {
            dto.setList(Collections.emptyList());
            return dto;
        }
        dto.setPages(page.getPages());
        dto.setTotal(page.getTotal());
        dto.setList(BeanUtil.copyToList(result, clazz));
        return dto;
    }

    public <PO, VO> PageResultDTO<VO> getPageResult(Page<PO> page,
                                                    Function<PO, VO> convertor) {
        // 3、封装分页结果
        PageResultDTO<VO> dto = new PageResultDTO<>();
        List<PO> result = page.getRecords();
        if (CollUtil.isEmpty(result)) {
            dto.setList(Collections.emptyList());
            return dto;
        }
        dto.setPages(page.getPages());
        dto.setTotal(page.getTotal());
        dto.setList(result.stream().map(convertor).collect(Collectors.toList()));
        return dto;
    }
}

6.3.3 改造业务逻辑

package com.itheima.mp.service.impl;

import ...

@Service
public class UserServiceImpl extends ... implements ... {
    ...
    @Override
    public PageResultDTO<UserVO> queryUsersWithPage(UserQuery query) {
        Integer status = query.getStatus();
        String name = query.getName();
        // 使用重构的方法：
        Page<User> page = query.toMpPage(query.getSortBy(), query.getIsAsc());
        // 2、分页查询
        Page<User> pageResult = lambdaQuery()
                .like(name != null, User::getUsername, name)
                .eq(status != null, User::getStatus, status)
                .page(page);
        // 调用方法1：直接复制属性
        //PageResultDTO<UserVO> dto = new PageResultDTO<>()
        //              .getPageResult(pageResult, UserVO.class);
        // 调用方法2：使用转换器，处理复杂转换
        PageResultDTO<UserVO> dto = new PageResultDTO<>()
                .getPageResult(pageResult, user -> {
                    // 拷贝基础属性
                    UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
                    userVO.setUsername(user.getUsername()
                            .substring(0, user.getUsername().length() - 2) + "**");
                    return userVO;
                });
        return dto;
    }
}

当前封装的两个方法（①根据前端查询条件构建Page ②根据page()的查询结果构建PageResultDTO）都是放到了实体的内部，和实体耦合在一起，有些情况下可能会出问题，例如公司里面用的不是MybatisPlus。可以采用单独另外封装工具类，而不是直接写在Query和VO的实体里面。

完结撒花 🎉