前言：

在 Web 应用开发中，持久层是连接应用与数据库的核心环节。MyBatis-Plus（简称 MP）作为 MyBatis 的增强工具，能大幅简化 CRUD 代码编写。今天就带大家从 0 到 1 实现 SpringBoot 与 MyBatis-Plus 的整合，轻松搞定持久层开发！

一、准备工作：环境与依赖配置

1. 开发环境

  • JDK：1.8+
  • IDE：IntelliJ IDEA
  • 数据库：MySQL 8.0
  • 构建工具：Maven

2. 引入核心依赖

在 SpringBoot 项目的pom.xml中添加以下依赖（直接复制即可）：

xml

<!-- SpringBoot Web核心 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- MySQL驱动 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- MyBatis-Plus Starter（自动整合MyBatis） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.5</version>
</dependency>

<!-- Lombok（简化实体类代码） -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

二、配置数据库连接

在application.yml（或application.properties）中配置数据库信息：

yaml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: 你的数据库密码
    driver-class-name: com.mysql.cj.jdbc.Driver

# MyBatis-Plus配置（可选）
mybatis-plus:
  mapper-locations: classpath:mapper/*.xml  # Mapper XML文件路径
  type-aliases-package: com.example.demo.entity  # 实体类包路径

三、核心步骤：代码编写

1. 创建数据库表

先在test_db库中创建一个测试表（以user表为例）：

sql

CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2. 编写实体类

在com.example.demo.entity包下创建User类（Lombok 自动生成 Getter/Setter）：

java

运行

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

@Data  // Lombok注解：自动生成Getter、Setter、toString等
public class User {
    @TableId(type = IdType.AUTO)  // 主键自增
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

3. 编写 Mapper 接口

在com.example.demo.mapper包下创建UserMapper接口（继承 MP 的BaseMapper，自带 CRUD 方法）：

java

运行

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper  // 标记为MyBatis Mapper接口（或在启动类加@MapperScan）
public interface UserMapper extends BaseMapper<User> {
    // 无需写任何方法，BaseMapper已提供：insert、deleteById、updateById、selectById等
}

4. 编写 Service 层（可选，简化业务代码）

（1）Service 接口

java

运行

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.demo.entity.User;

public interface UserService extends IService<User> {
    // 可自定义业务方法，IService已提供批量操作、分页等方法
}
（2）Service 实现类

java

运行

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    // 无需写代码，ServiceImpl已整合Mapper和通用方法
}

5. 编写 Controller 测试

在com.example.demo.controller包下创建UserController，测试 CRUD 接口：

java

运行

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    // 新增用户
    @PostMapping
    public boolean addUser(@RequestBody User user) {
        return userService.save(user);
    }

    // 查询所有用户
    @GetMapping
    public List<User> listUsers() {
        return userService.list();
    }

    // 根据ID查询用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }

    // 修改用户
    @PutMapping
    public boolean updateUser(@RequestBody User user) {
        return userService.updateById(user);
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.removeById(id);
    }
}

四、测试效果

启动 SpringBoot 项目，用 Postman 或浏览器测试接口：

  1. 新增用户：POST 请求http://localhost:8080/user，请求体传{"name":"张三","age":20,"email":"zhangsan@test.com"}
  2. 查询所有用户：GET 请求http://localhost:8080/user，即可看到新增的用户数据

五、MyBatis-Plus 进阶：常用功能

  • 条件构造器：用QueryWrapper实现复杂查询（如userService.list(new QueryWrapper<User>().eq("age",20))）
  • 分页查询：配置PaginationInterceptor后，用Page<User> page = new Page<>(1,10); userService.page(page);
  • 逻辑删除：在实体类字段加@TableLogic，实现假删除

要不要我帮你补充MyBatis-Plus 条件构造器 + 分页查询的详细示例代码？

重新生成，长一点

你希望我重新生成一篇更长、内容更详实的《SpringBoot + MyBatis-Plus 超详细整合教程》技术博客，我会在原有基础上补充更多核心知识点、实操案例和进阶功能讲解，让内容更丰富。

《SpringBoot + MyBatis-Plus 超详细整合教程：从 0 到 1 快速上手持久层开发》

在 Web 应用开发中，持久层是连接应用程序与数据库的核心桥梁，其开发效率直接影响整个项目的进度。MyBatis 作为半自动化的 ORM 框架，凭借灵活的 SQL 编写能力被广泛使用，但原生 MyBatis 需要编写大量的 XML 映射文件和 CRUD 模板代码，效率较低。而MyBatis-Plus（简称 MP） 作为 MyBatis 的增强工具，在保留 MyBatis 原有特性的基础上，提供了强大的通用 CRUD、条件构造、分页查询等功能，能大幅简化持久层代码的编写。

今天，我将带大家从 0 到 1 完整实现 SpringBoot 与 MyBatis-Plus 的整合，不仅涵盖基础的环境搭建和 CRUD 操作，还会深入讲解条件构造器、分页查询、逻辑删除、代码生成器等进阶功能，帮助你彻底搞定持久层开发！

一、准备工作：开发环境与工具

在开始编码前，我们需要先搭建好对应的开发环境，确保后续操作顺利进行。

1. 核心开发环境

  • JDK：1.8 及以上（SpringBoot 2.x + 和 MyBatis-Plus 3.x + 均推荐使用 JDK8）
  • IDE：IntelliJ IDEA 2020.3+（推荐，也可使用 Eclipse）
  • 数据库：MySQL 8.0（5.7 版本也可，配置略有差异）
  • 构建工具：Maven 3.6+（也可使用 Gradle，本文以 Maven 为例）
  • SpringBoot 版本：2.7.15（稳定版，与 MyBatis-Plus 3.5.5 兼容性好）

2. 初始化 SpringBoot 项目

你可以通过Spring Initializr（https://start.spring.io/）快速初始化一个 SpringBoot 项目，也可以在 IDEA 中直接创建：

  1. 打开 IDEA，选择New Project -> Spring Initializr
  2. 填写项目信息：Group（如com.example）、Artifact（如mp-demo）、Java Version（8）
  3. 选择依赖：仅勾选Spring Web（其他依赖后续手动添加）
  4. 点击Finish完成项目创建

二、核心依赖引入

在项目的pom.xml文件中，添加 MyBatis-Plus、MySQL 驱动、Lombok 等核心依赖。Lombok 可以简化实体类代码，减少 Getter/Setter 等模板代码的编写，是开发中常用的工具。

xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.15</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mp-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mp-demo</name>
    <description>SpringBoot + MyBatis-Plus Demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- SpringBoot Web核心依赖：用于编写接口 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- MySQL驱动：连接MySQL数据库 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- MyBatis-Plus Starter：自动整合MyBatis和SpringBoot -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.5</version>
        </dependency>

        <!-- Lombok：简化实体类代码 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- SpringBoot测试依赖：用于单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- MyBatis-Plus代码生成器依赖（可选，后续进阶功能使用） -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.5</version>
        </dependency>

        <!-- 模板引擎：代码生成器需要 -->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.32</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

三、数据库与配置文件设置

1. 创建 MySQL 数据库与测试表

首先，打开 MySQL 客户端（如 Navicat、MySQL Workbench），创建一个名为mp_test的数据库，并创建user表作为测试表，表结构如下：

sql

-- 创建数据库
CREATE DATABASE IF NOT EXISTS mp_test DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- 使用数据库
USE mp_test;

-- 创建用户表
CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `deleted` tinyint(1) DEFAULT 0 COMMENT '逻辑删除标识（0：未删除，1：已删除）',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

-- 插入测试数据
INSERT INTO `user` (`name`, `age`, `email`, `create_time`, `update_time`) VALUES
('张三', 20, 'zhangsan@test.com', NOW(), NOW()),
('李四', 22, 'lisi@test.com', NOW(), NOW()),
('王五', 25, 'wangwu@test.com', NOW(), NOW()),
('赵六', 18, 'zhaoliu@test.com', NOW(), NOW());

2. 配置 application.yml 文件

在 SpringBoot 项目中，我们使用application.yml（比 properties 更简洁）配置数据库连接信息和 MyBatis-Plus 相关配置。在src/main/resources目录下创建application.yml文件：

yaml

# 服务器配置
server:
  port: 8080  # 项目启动端口

# Spring配置
spring:
  # 数据库连接配置
  datasource:
    url: jdbc:mysql://localhost:3306/mp_test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root  # 你的MySQL用户名
    password: 123456  # 你的MySQL密码
    driver-class-name: com.mysql.cj.jdbc.Driver  # MySQL8.0+驱动类（5.7版本是com.mysql.jdbc.Driver）

# MyBatis-Plus配置
mybatis-plus:
  # Mapper XML文件路径：如果需要自定义SQL，可在xml中编写
  mapper-locations: classpath:mapper/*.xml
  # 实体类包路径：用于别名映射，简化XML中的类名编写
  type-aliases-package: com.example.mpdemo.entity
  # 全局配置
  global-config:
    db-config:
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除未删除值
      logic-not-delete-value: 0
      # 逻辑删除已删除值
      logic-delete-value: 1
      # 主键生成策略：AUTO（自增）、ASSIGN_ID（雪花算法生成ID）等
      id-type: AUTO
  # 配置MyBatis的日志：开发时可开启，方便调试SQL
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 开启驼峰命名自动转换（如数据库字段create_time对应实体类createTime）
    map-underscore-to-camel-case: true

关键配置说明：

  • log-impl：开启 MyBatis 的控制台日志，开发时可以看到执行的 SQL 语句，方便调试。
  • map-underscore-to-camel-case：开启驼峰命名转换，数据库中的create_time字段会自动映射到实体类的createTime属性。
  • logic-delete-field：配置逻辑删除的字段名，配合 MyBatis-Plus 的逻辑删除功能使用。

四、核心代码编写：从实体类到接口测试

1. 编写实体类（Entity）

在com.example.mpdemo包下创建entity子包，然后创建User实体类，对应数据库中的user表。使用 Lombok 的@Data注解简化代码，MyBatis-Plus 的注解配置表字段映射关系：

java

运行

package com.example.mpdemo.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;

/**
 * 用户实体类
 * 对应数据库中的user表
 */
@Data  // Lombok注解：自动生成Getter、Setter、toString、equals、hashCode等方法
@TableName("user")  // 指定数据库表名（如果实体类名与表名一致，可省略）
public class User {

    /**
     * 主键ID
     * @TableId：指定主键字段，type=IdType.AUTO表示自增（与数据库表的主键自增对应）
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 姓名
     * 字段名与属性名一致，可省略@TableField注解
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 创建时间
     * @TableField(fill = FieldFill.INSERT)：表示插入时自动填充，需要配合元对象处理器使用
     */
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    /**
     * 更新时间
     * @TableField(fill = FieldFill.INSERT_UPDATE)：表示插入和更新时自动填充
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;

    /**
     * 逻辑删除标识
     * @TableLogic：指定逻辑删除字段（也可在全局配置中统一设置，这里是局部配置，优先级更高）
     */
    @TableLogic
    private Integer deleted;
}

2. 编写元对象处理器（自动填充时间字段）

上面的实体类中，createTime和updateTime字段配置了自动填充（FieldFill.INSERT和FieldFill.INSERT_UPDATE），需要编写元对象处理器来实现自动填充逻辑。在com.example.mpdemo包下创建handler子包，创建MyMetaObjectHandler类：

java

运行

package com.example.mpdemo.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;

/**
 * 元对象处理器：实现字段自动填充（如创建时间、更新时间）
 */
@Component  // 交给Spring容器管理
public class MyMetaObjectHandler implements MetaObjectHandler {

    /**
     * 插入操作时的字段填充
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        // 填充createTime字段：插入时设置为当前时间
        this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now());
        // 填充updateTime字段：插入时也设置为当前时间
        this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }

    /**
     * 更新操作时的字段填充
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        // 填充updateTime字段：更新时设置为当前时间
        this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now());
    }
}

3. 编写 Mapper 接口

MyBatis-Plus 的核心优势之一是提供了BaseMapper接口，该接口内置了大量的 CRUD 方法，无需我们手动编写 SQL。在com.example.mpdemo包下创建mapper子包，创建UserMapper接口：

java

运行

package com.example.mpdemo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mpdemo.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

/**
 * 用户Mapper接口：继承BaseMapper，获得通用CRUD方法
 */
@Mapper  // 标记为MyBatis的Mapper接口，SpringBoot会自动扫描并创建代理对象
// 也可以在启动类上添加@MapperScan("com.example.mpdemo.mapper")注解，批量扫描Mapper接口
public interface UserMapper extends BaseMapper<User> {

    /**
     * 自定义SQL：根据年龄查询用户（示例）
     * 可在resources/mapper/UserMapper.xml中编写SQL，也可使用注解编写
     */
    List<User> selectUserByAge(Integer age);
}

说明：如果有多个 Mapper 接口，推荐在启动类上添加@MapperScan("com.example.mpdemo.mapper")注解，批量扫描 Mapper 接口，这样每个 Mapper 接口就不需要加@Mapper注解了。修改项目启动类MpDemoApplication：

java

运行

package com.example.mpdemo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 项目启动类
 * @MapperScan：扫描Mapper接口所在的包
 */
@SpringBootApplication
@MapperScan("com.example.mpdemo.mapper")
public class MpDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MpDemoApplication.class, args);
    }

}

4. 编写 Service 层（业务层）

Service 层用于处理业务逻辑，MyBatis-Plus 提供了IService和ServiceImpl来封装 Service 层的通用方法，比BaseMapper更强大，支持批量操作、分页查询等。

（1）编写 UserService 接口

在com.example.mpdemo包下创建service子包，创建UserService接口：

java

运行

package com.example.mpdemo.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.mpdemo.entity.User;
import java.util.List;

/**
 * 用户Service接口：继承IService，获得通用业务方法
 */
public interface UserService extends IService<User> {

    /**
     * 自定义业务方法：根据年龄查询用户
     */
    List<User> getUserByAge(Integer age);
}
（2）编写 UserServiceImpl 实现类

在service包下创建impl子包，创建UserServiceImpl实现类：

java

运行

package com.example.mpdemo.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.mpdemo.entity.User;
import com.example.mpdemo.mapper.UserMapper;
import com.example.mpdemo.service.UserService;
import org.springframework.stereotype.Service;
import java.util.List;

/**
 * 用户Service实现类：继承ServiceImpl，实现UserService接口
 * ServiceImpl<Mapper, Entity>：指定Mapper接口和实体类
 */
@Service  // 标记为Spring的Service组件
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    /**
     * 实现自定义业务方法：调用Mapper的自定义方法
     */
    @Override
    public List<User> getUserByAge(Integer age) {
        return baseMapper.selectUserByAge(age);
    }
}

说明：ServiceImpl中提供了baseMapper属性，可直接调用 Mapper 接口的方法，无需手动注入 Mapper。

5. 编写自定义 SQL 的 Mapper XML 文件（可选）

如果需要编写自定义 SQL，可在src/main/resources目录下创建mapper文件夹，然后创建UserMapper.xml文件，编写自定义 SQL：

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接口的全限定名 -->
<mapper namespace="com.example.mpdemo.mapper.UserMapper">

    <!-- 自定义SQL：根据年龄查询用户 -->
    <select id="selectUserByAge" resultType="com.example.mpdemo.entity.User">
        SELECT * FROM user WHERE age = #{age} AND deleted = 0
    </select>

</mapper>

6. 编写 Controller 层（控制层）

Controller 层用于处理前端请求，返回数据。在com.example.mpdemo包下创建controller子包，创建UserController类：

java

运行

package com.example.mpdemo.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.mpdemo.entity.User;
import com.example.mpdemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

/**
 * 用户控制器：处理用户相关的HTTP请求
 */
@RestController  // 组合注解：@Controller + @ResponseBody，返回JSON数据
@RequestMapping("/user")  // 接口前缀
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 1. 查询所有用户（自动过滤逻辑删除的数据）
     */
    @GetMapping("/list")
    public List<User> listUsers() {
        return userService.list();
    }

    /**
     * 2. 根据ID查询用户
     */
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }

    /**
     * 3. 新增用户
     */
    @PostMapping("/add")
    public boolean addUser(@RequestBody User user) {
        return userService.save(user);
    }

    /**
     * 4. 修改用户
     */
    @PutMapping("/update")
    public boolean updateUser(@RequestBody User user) {
        return userService.updateById(user);
    }

    /**
     * 5. 删除用户（逻辑删除）
     */
    @DeleteMapping("/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.removeById(id);
    }

    /**
     * 6. 根据年龄查询用户（自定义业务方法）
     */
    @GetMapping("/age/{age}")
    public List<User> getUserByAge(@PathVariable Integer age) {
        return userService.getUserByAge(age);
    }

    /**
     * 7. 条件查询：根据姓名模糊查询 + 年龄大于指定值
     */
    @GetMapping("/condition")
    public List<User> getUserByCondition(@RequestParam String name, @RequestParam Integer age) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        // 姓名模糊查询：like("%{name}%")
        queryWrapper.like("name", name);
        // 年龄大于：gt(age)
        queryWrapper.gt("age", age);
        return userService.list(queryWrapper);
    }

    /**
     * 8. 分页查询：查询第1页，每页显示2条数据
     */
    @GetMapping("/page")
    public IPage<User> getUserByPage() {
        // 创建分页对象：Page(当前页，每页条数)
        Page<User> page = new Page<>(1, 2);
        // 执行分页查询
        return userService.page(page);
    }
}

五、配置分页插件

MyBatis-Plus 的分页查询需要配置分页插件才能生效。在com.example.mpdemo包下创建config子包，创建MyBatisPlusConfig配置类：

java

运行

package com.example.mpdemo.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;

/**
 * MyBatis-Plus配置类：配置分页插件等
 */
@Configuration  // 标记为Spring的配置类
public class MyBatisPlusConfig {

    /**
     * 配置分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页插件，指定数据库类型（MySQL）
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

六、测试项目

1. 启动项目

运行项目启动类MpDemoApplication，控制台会输出 SpringBoot 的启动日志，同时 MyBatis 的日志会显示加载的 Mapper 接口和 SQL 语句。

2. 测试接口

可以使用Postman、Apifox或浏览器测试接口，以下是部分接口的测试示例：

  • 查询所有用户：GET 请求 http://localhost:8080/user/list
  • 根据 ID 查询用户：GET 请求 http://localhost:8080/user/1
  • 新增用户：POST 请求 http://localhost:8080/user/add，请求体为{"name":"孙七","age":28,"email":"sunqi@test.com"}
  • 分页查询：GET 请求 http://localhost:8080/user/page

七、MyBatis-Plus 进阶功能：代码生成器

手动编写实体类、Mapper、Service、Controller 等代码仍然比较繁琐，MyBatis-Plus 提供了代码生成器，可以根据数据库表自动生成所有代码，大幅提升开发效率。

在com.example.mpdemo包下创建generator子包，创建CodeGenerator类：

java

运行

package com.example.mpdemo.generator;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import java.util.Collections;

/**
 * MyBatis-Plus代码生成器：根据数据库表自动生成代码
 */
public class CodeGenerator {

    public static void main(String[] args) {
        // 数据库连接配置
        String url = "jdbc:mysql://localhost:3306/mp_test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false";
        String username = "root";
        String password = "123456";

        // 快速生成代码
        FastAutoGenerator.create(url, username, password)
                // 全局配置
                .globalConfig(builder -> {
                    builder.author("程序员") // 设置作者
                            .enableSwagger() // 开启Swagger注解（需要添加Swagger依赖）
                            .fileOverride() // 覆盖已生成文件
                            .outputDir(System.getProperty("user.dir") + "/src/main/java"); // 输出目录
                })
                // 包配置
                .packageConfig(builder -> {
                    builder.parent("com.example.mpdemo") // 父包名
                            .moduleName("") // 模块名（无则为空）
                            .entity("entity") // 实体类包名
                            .mapper("mapper") // Mapper接口包名
                            .service("service") // Service接口包名
                            .serviceImpl("service.impl") // Service实现类包名
                            .controller("controller") // Controller包名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, System.getProperty("user.dir") + "/src/main/resources/mapper")); // Mapper XML文件输出路径
                })
                // 策略配置
                .strategyConfig(builder -> {
                    builder.addInclude("user") // 设置要生成的表名（可多个，逗号分隔）
                            .addTablePrefix("t_", "sys_") // 过滤表前缀（如t_user会生成User实体类）
                            // 实体类策略
                            .entityBuilder()
                            .enableLombok() // 开启Lombok注解
                            .enableTableFieldAnnotation() // 开启字段注解
                            // Controller策略
                            .controllerBuilder()
                            .enableRestStyle() // 开启RestController风格
                            .enableHyphenStyle() // 开启URL连字符风格（如/user/info-id）
                            // Mapper策略
                            .mapperBuilder()
                            .enableMapperAnnotation() // 开启Mapper注解
                            .enableBaseResultMap() // 开启BaseResultMap
                            .enableBaseColumnList(); // 开启BaseColumnList
                })
                // 模板引擎：使用Freemarker（默认是Velocity）
                .templateEngine(new FreemarkerTemplateEngine())
                // 执行生成
                .execute();
    }
}

使用说明：运行CodeGenerator的main方法，即可根据mp_test数据库中的user表自动生成实体类、Mapper、Service、Controller 等代码。如果需要生成 Swagger 注解，需在pom.xml中添加 Swagger 依赖。

八、常见问题与解决方案

  1. 分页查询返回空数据：未配置分页插件，需在MyBatisPlusConfig中添加分页插件。
  2. 逻辑删除不生效：未配置全局逻辑删除字段，或实体类中未添加@TableLogic注解。
  3. 驼峰命名转换不生效：未开启map-underscore-to-camel-case配置，或字段名与属性名映射错误。
  4. Mapper 接口注入失败：未添加@Mapper注解或@MapperScan注解，导致 Spring 无法扫描到 Mapper 接口。

总结

  1. 核心整合步骤：搭建 SpringBoot 项目 → 引入 MyBatis-Plus 等依赖 → 配置数据库连接 → 编写实体类、Mapper、Service、Controller → 配置分页插件 → 测试接口。
  2. MyBatis-Plus 优势：通过BaseMapper和IService封装了通用 CRUD 方法，无需手动编写 SQL；支持条件构造器、分页查询、逻辑删除等功能，大幅提升开发效率。
  3. 进阶技巧：使用代码生成器可自动生成各类代码，减少重复劳动；自定义 SQL 可通过 Mapper XML 文件或注解实现，兼顾灵活性。

这篇教程覆盖了 SpringBoot 与 MyBatis-Plus 整合的全流程，从基础到进阶，希望能帮助你快速掌握持久层开发的技巧！如果有问题，欢迎在评论区交流～

# spring boot
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

2026最新AI Agent高频面试题（分类型精简详解）

本文梳理AI Agent高频面试考点，覆盖基础概念、架构、推理规划、工具调用、记忆、RAG融合、多智能体与工程落地。区分Agent、Workflow与普通工具调用，讲解ReAct、Plan‑and‑Execute等主流范式，分析三级记忆机制与上下文溢出的解决办法，对比传统RAG与Agent‑RAG差异，介绍多智能体协作模式。同时总结落地痛点、优化手段和安全风控要点，划分初/中/高级面试复习重点，可

avatar AI Agent技术社区
cover

深入理解 AI Agent · AGENT #03：从单 Agent 到多 Agent

avatar AI Agent技术社区
cover

AI Agent安全风险启示：工业巡检机器人的AI安全管控

avatar AI Agent技术社区