Spring Boot + MyBatis-Plus 快速实现单表 CRUD

Spring Boot + MyBatis-Plus 快速实现单表 CRUD

在Spring Boot项目开发中，单表CRUD（新增Create、查询Retrieve、修改Update、删除Delete）是最基础、最常用的操作。传统MyBatis实现CRUD需要编写大量XML映射文件和SQL语句，繁琐且易出错；而MyBatis-Plus（MP）作为MyBatis的增强工具，通过内置接口和注解，实现了单表CRUD的“零XML、零SQL”极简开发，新手也能快速上手。

本文基于「Spring Boot + MyBatis-Plus + MySQL」技术栈，全程贴合实战，从环境准备、项目搭建、代码编写到测试验证，一步步教你快速实现单表CRUD，同时梳理高频踩坑点和最佳实践，确保你不仅能实现功能，还能规范编码、规避问题，适配日常开发场景。

前置说明：本文默认你已掌握「Spring Boot + MyBatis-Plus 连接MySQL」的基础操作（数据库连接、依赖导入），若未掌握，可先完成数据库连接配置，再继续本文内容（文末附基础连接补充）。

一、前置准备（极简版，快速适配）

确保本地环境和项目依赖满足要求，避免版本不兼容导致功能异常，直接照搬配置即可。

1. 环境要求

• JDK：1.8 及以上（优先1.8，兼容性最佳）；

• Spring Boot：2.7.x 稳定版（新手避开3.x，减少语法差异踩坑）；

• MyBatis-Plus：3.5.x 版本（与Spring Boot 2.7.x 完美适配）；

• MySQL：5.7 / 8.0 版本（本文以MySQL 8.0为例，5.7仅驱动配置有差异）；

• 开发工具：IDEA（社区版）、MySQL客户端（Navicat/Workbench）；

• 辅助依赖：Lombok（简化实体类编写，可选但强烈推荐）。

2. 核心依赖（pom.xml）

项目中需引入以下核心依赖，若已创建项目，核对并补充即可；若新建项目，IDEA勾选对应选项自动导入。

<!-- Spring Boot 核心启动器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- MyBatis-Plus 启动器（核心，内置MyBatis，无需单独引入） -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>

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

<!-- Lombok（简化实体类，无需写get/set、toString） -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

<!-- 测试依赖（用于测试CRUD功能） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

3. 数据库与表准备

提前创建测试数据库和单表，本文以「用户表（user）」为例，执行以下SQL语句（MySQL客户端中运行），确保表结构和字段与后续实体类对应。

-- 1. 创建数据库（名称：mp_demo，可自定义，需与yml配置一致）
CREATE DATABASE IF NOT EXISTS mp_demo 
DEFAULT CHARACTER SET utf8mb4 
DEFAULT COLLATE utf8mb4_general_ci;

-- 2. 切换到目标数据库
USE mp_demo;

-- 3. 创建用户表（user），单表CRUD测试用
CREATE TABLE IF NOT EXISTS `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID（自增）',
  `name` varchar(30) NOT NULL COMMENT '用户姓名',
  `age` int(11) DEFAULT NULL COMMENT '用户年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '用户邮箱',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

4. 核心配置（application.yml）

编写数据库连接配置和MyBatis-Plus基础配置，重点修改数据库名称、账号、密码，其余配置直接复用，确保CRUD操作能正常关联数据库。

# 服务器配置（可选，避免端口冲突）
server:
  port: 8081
  servlet:
    context-path: /crud-demo

# 数据库连接配置（核心，必须修改）
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver  # MySQL 8.0 驱动类
    url: jdbc:mysql://localhost:3306/mp_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username: root  # 你的MySQL账号（默认root）
    password: 123456  # 你的MySQL密码

# MyBatis-Plus 配置（简化CRUD关键）
mybatis-plus:
  type-aliases-package: com.example.cruddemo.entity  # 实体类包路径（修改为你的包名）
  mapper-locations: classpath:mapper/**/*.xml  # 自定义SQL的XML路径（本文暂用不到，预留）
  configuration:
    map-underscore-to-camel-case: true  # 开启下划线转驼峰（数据库create_time → 实体类createTime）
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 开启SQL日志打印（便于调试，查看执行的SQL）
  global-config:
    db-config:
      table-prefix:  # 表前缀（若表名有前缀，如mp_user，此处填mp_，本文无前缀，留空）
      id-type: AUTO  # 主键自增策略（与数据库表id自增对应）

避坑提醒：若使用MySQL 5.7，需将驱动类改为「com.mysql.jdbc.Driver」，并删除url中的「serverTimezone=GMT%2B8」配置，驱动依赖替换为mysql-connector-java:5.1.47。

二、核心代码编写（零XML、零SQL，快速实现CRUD）

MyBatis-Plus的核心优势的是「BaseMapper接口」和「IService接口」，两者都内置了完整的单表CRUD方法，无需手动编写SQL。本文分别演示两种方式（新手优先掌握BaseMapper，简化开发；IService适合复杂业务场景）。

项目包结构规范（必遵循，避免扫描失败）：

com.example.cruddemo  # 项目根包
├── CrudDemoApplication.java  # 启动类
├── entity  # 实体类包（对应数据库表）
│   └── User.java
├── mapper  # Mapper接口包（继承BaseMapper）
│   └── UserMapper.java
├── service  # 服务层包（继承IService，可选）
│   ├── UserService.java
│   └── impl
│       └── UserServiceImpl.java
└── controller  # 控制层包（编写接口，测试CRUD，可选）
    └── UserController.java

1. 第一步：编写实体类（Entity）

实体类与数据库表一一对应，通过Lombok简化代码，通过MyBatis-Plus注解指定表名、主键策略等（若实体类名与表名一致、字段名与数据库字段一致，部分注解可省略）。

package com.example.cruddemo.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.util.Date;

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

    /**
     * 主键ID，自增
     * @TableId：指定主键，type=IdType.AUTO 对应数据库自增策略
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 用户名，对应数据库name字段
     * 字段名与数据库一致，无需额外注解
     */
    private String name;

    /**
     * 年龄，对应数据库age字段
     */
    private Integer age;

    /**
     * 邮箱，对应数据库email字段
     */
    private String email;

    /**
     * 创建时间，对应数据库create_time字段
     * @TableField：指定数据库字段名（下划线转驼峰可省略，此处用于演示）
     * fill = FieldFill.INSERT：插入时自动填充时间（无需手动设置）
     */
    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Date createTime;

    /**
     * 更新时间，对应数据库update_time字段
     * fill = FieldFill.INSERT_UPDATE：插入和更新时自动填充时间
     */
    @TableField(value = "update_time", fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

2. 第二步：时间自动填充配置（可选，优化体验）

实体类中createTime和updateTime字段配置了「自动填充」，需编写填充处理器，实现插入/更新时自动填充当前时间，无需手动设置字段值。

package com.example.cruddemo.config;

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

/**
 * MyBatis-Plus 时间自动填充处理器
 */
@Component  // 交给Spring管理，必须添加该注解
public class MyMetaObjectHandler implements MetaObjectHandler {

    // 插入时自动填充
    @Override
    public void insertFill(MetaObject metaObject) {
        // 填充createTime和updateTime字段，值为当前时间
        strictInsertFill(metaObject, "createTime", Date.class, new Date());
        strictInsertFill(metaObject, "updateTime", Date.class, new Date());
    }

    // 更新时自动填充
    @Override
    public void updateFill(MetaObject metaObject) {
        // 只填充updateTime字段，值为当前时间
        strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

3. 方式1：基于BaseMapper实现CRUD（新手首选）

BaseMapper是MyBatis-Plus提供的基础Mapper接口，内置了完整的单表CRUD方法（insert、selectById、selectList、updateById、deleteById等），只需让自定义Mapper接口继承BaseMapper，无需编写任何方法，即可直接使用。

3.1 编写Mapper接口

package com.example.cruddemo.mapper;

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

/**
 * UserMapper接口，继承BaseMapper，实现单表CRUD
 * @Mapper：标记为MyBatis-Plus的Mapper接口，让Spring Boot自动扫描
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 无需编写任何方法！BaseMapper已内置所有单表CRUD方法
}

3.2 启动类添加Mapper扫描（关键避坑）

打开项目启动类，添加@MapperScan注解，指定Mapper接口所在的包路径，否则Spring Boot无法扫描到Mapper接口，会导致注入失败。

package com.example.cruddemo;

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

@SpringBootApplication
@MapperScan("com.example.cruddemo.mapper")  // 扫描Mapper接口包（修改为你的包名）
public class CrudDemoApplication {

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

}

3.3 BaseMapper核心CRUD方法（常用，必记）

BaseMapper内置了数十种方法，以下是单表CRUD最常用的方法，直接调用即可，无需写SQL：

方法名	功能描述	示例
insert(T entity)	新增一条数据（返回影响行数）	userMapper.insert(user);
selectById(Serializable id)	根据主键ID查询一条数据	userMapper.selectById(1L);
selectList(QueryWrapper queryWrapper)	查询所有数据（可加条件）	userMapper.selectList(null);（查询所有）
updateById(T entity)	根据主键ID修改数据（非null字段才修改）	userMapper.updateById(user);
deleteById(Serializable id)	根据主键ID删除一条数据	userMapper.deleteById(1L);
selectCount(QueryWrapper queryWrapper)	统计数据条数（可加条件）	userMapper.selectCount(null);（统计所有）

4. 方式2：基于IService实现CRUD（适合业务层开发）

IService是MyBatis-Plus提供的服务层接口，基于BaseMapper封装，提供了更丰富的CRUD方法（如批量操作、分页查询），还支持自定义业务逻辑，适合实际开发中的服务层编写（推荐项目开发使用）。

4.1 编写Service接口（继承IService）

package com.example.cruddemo.service;

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

/**
 * UserService接口，继承IService，封装CRUD方法和业务逻辑
 */
public interface UserService extends IService<User> {
    // 此处可添加自定义业务方法（如根据姓名查询用户），基础CRUD方法IService已内置
}

4.2 编写Service实现类（继承ServiceImpl）

package com.example.cruddemo.service.impl;

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

/**
 * Service实现类，继承ServiceImpl，关联Mapper和Entity
 * @Service：标记为Spring服务层组件，交给Spring管理
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    // 基础CRUD方法无需编写，IService/ServiceImpl已内置
    // 示例：自定义业务方法（根据姓名查询用户，后续可扩展）
    /*
    public User selectByName(String name) {
        // 用QueryWrapper构建查询条件（下文会演示）
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name);
        return baseMapper.selectOne(queryWrapper);
    }
    */
}

4.3 IService核心CRUD方法（常用）

IService在BaseMapper基础上做了增强，新增了批量操作、分页等方法，常用方法如下：

• 新增：save(T entity)（等同于insert）、saveBatch(Collection entityList)（批量新增）；

• 查询：getById(Serializable id)（等同于selectById）、list()（查询所有）、count()（统计条数）；

• 修改：updateById(T entity)（等同于updateById）、updateBatchById(Collection entityList)（批量修改）；

• 删除：removeById(Serializable id)（等同于deleteById）、removeBatchByIds(Collection<?> idList)（批量删除）。

三、测试验证（两种方式，确保CRUD功能正常）

本文通过「Spring Boot测试类」直接测试CRUD功能，无需编写接口，简单高效；后续也可通过控制层编写接口，用Postman测试（文末附控制层示例）。

1. 测试BaseMapper方式（新手优先）

在test目录下，找到默认的测试类，注入UserMapper，编写测试方法，逐一验证CRUD功能。

package com.example.cruddemo;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.cruddemo.entity.User;
import com.example.cruddemo.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;

@SpringBootTest  // 标记为Spring Boot测试类，启动Spring容器
class CrudDemoApplicationTests {

    // 自动注入UserMapper（Spring扫描@Mapper注解后，自动创建实例）
    @Autowired
    private UserMapper userMapper;

    /**
     * 测试1：新增用户（Create）
     */
    @Test
    void testInsert() {
        // 创建User对象，无需设置id（自增）、createTime、updateTime（自动填充）
        User user = new User();
        user.setName("张三");
        user.setAge(22);
        user.setEmail("zhangsan@163.com");

        // 调用BaseMapper的insert方法，新增数据
        int rows = userMapper.insert(user);
        System.out.println("新增成功，影响行数：" + rows);
        System.out.println("新增用户ID：" + user.getId());  // 新增后，自增ID会自动回显
    }

    /**
     * 测试2：根据ID查询用户（Retrieve）
     */
    @Test
    void testSelectById() {
        // 调用selectById方法，根据ID查询（ID为新增时回显的ID，可修改为自己的）
        User user = userMapper.selectById(1L);
        System.out.println("查询到的用户信息：" + user);
    }

    /**
     * 测试3：查询所有用户 + 条件查询（Retrieve）
     */
    @Test
    void testSelectList() {
        // 1. 查询所有用户（无条件，queryWrapper传null）
        List<User> allUser = userMapper.selectList(null);
        System.out.println("所有用户：" + allUser);

        // 2. 条件查询（示例：查询年龄>20的用户）
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age", 20);  // gt表示“大于”，eq表示“等于”，lt表示“小于”
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println("年龄大于20的用户：" + userList);
    }

    /**
     * 测试4：根据ID修改用户（Update）
     */
    @Test
    void testUpdateById() {
        // 1. 先查询要修改的用户（确保用户存在）
        User user = userMapper.selectById(1L);
        // 2. 修改用户信息（仅修改非null字段）
        user.setAge(23);  // 修改年龄
        user.setEmail("zhangsan_update@163.com");  // 修改邮箱

        // 3. 调用updateById方法，修改数据
        int rows = userMapper.updateById(user);
        System.out.println("修改成功，影响行数：" + rows);
    }

    /**
     * 测试5：根据ID删除用户（Delete）
     */
    @Test
    void testDeleteById() {
        // 调用deleteById方法，根据ID删除（ID为要删除的用户ID，谨慎操作）
        int rows = userMapper.deleteById(1L);
        System.out.println("删除成功，影响行数：" + rows);
    }
}

2. 测试IService方式（服务层测试）

注入UserService，测试IService内置的CRUD方法，用法与BaseMapper类似，更贴合实际业务开发。

package com.example.cruddemo;

import com.example.cruddemo.entity.User;
import com.example.cruddemo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;

@SpringBootTest
class UserServiceTest {

    // 自动注入UserService（@Service注解标记，Spring自动管理）
    @Autowired
    private UserService userService;

    // 测试新增
    @Test
    void testSave() {
        User user = new User();
        user.setName("李四");
        user.setAge(25);
        user.setEmail("lisi@163.com");
        boolean success = userService.save(user);  // IService返回boolean，更直观
        System.out.println("新增是否成功：" + success);
    }

    // 测试查询所有
    @Test
    void testList() {
        List<User> userList = userService.list();
        System.out.println("所有用户：" + userList);
    }

    // 测试修改
    @Test
    void testUpdateById() {
        User user = new User();
        user.setId(2L);  // 必须设置ID，否则无法修改
        user.setAge(26);
        boolean success = userService.updateById(user);
        System.out.println("修改是否成功：" + success);
    }

    // 测试删除
    @Test
    void testRemoveById() {
        boolean success = userService.removeById(2L);
        System.out.println("删除是否成功：" + success);
    }

    // 测试批量新增（IService增强方法）
    @Test
    void testSaveBatch() {
        User user1 = new User();
        user1.setName("王五");
        user1.setAge(28);
        user1.setEmail("wangwu@163.com");

        User user2 = new User();
        user2.setName("赵六");
        user2.setAge(30);
        user2.setEmail("zhaoliu@163.com");

        List<User> userList = List.of(user1, user2);
        boolean success = userService.saveBatch(userList);
        System.out.println("批量新增是否成功：" + success);
    }
}

3. 测试成功标志

1. 运行所有测试方法，控制台无红色报错；

2. SQL日志正常打印（开启了log-impl配置），能看到自动生成的SQL语句；

3. 打开MySQL客户端，查询user表，能看到新增、修改、删除后的对应数据；

4. 条件查询、批量操作能返回正确结果。

四、可选扩展：编写控制层接口（Postman测试）

实际开发中，CRUD功能通常通过接口对外提供，这里编写简单的RESTful接口，用Postman测试，贴合真实开发场景。

package com.example.cruddemo.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.cruddemo.entity.User;
import com.example.cruddemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

/**
 * 用户控制层，编写CRUD接口
 * @RestController：等同于@Controller + @ResponseBody，返回JSON数据
 * @RequestMapping：接口统一前缀
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    // 1. 新增用户（POST请求）
    @PostMapping("/add")
    public String addUser(@RequestBody User user) {
        boolean success = userService.save(user);
        return success ? "新增成功" : "新增失败";
    }

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

    // 3. 查询所有用户（GET请求）
    @GetMapping("/list")
    public List<User> getUserList() {
        return userService.list();
    }

    // 4. 根据ID修改用户（PUT请求）
    @PutMapping("/update")
    public String updateUser(@RequestBody User user) {
        boolean success = userService.updateById(user);
        return success ? "修改成功" : "修改失败";
    }

    // 5. 根据ID删除用户（DELETE请求）
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        boolean success = userService.removeById(id);
        return success ? "删除成功" : "删除失败";
    }

    // 6. 条件查询（示例：根据姓名查询）
    @GetMapping("/list/name")
    public List<User> getUserByName(@RequestParam String name) {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name);
        return userService.list(queryWrapper);
    }
}

接口测试方法：启动项目，打开Postman，根据接口请求方式（POST/PUT/GET/DELETE），输入接口地址（如 http://localhost:8081/crud-demo/api/user/add），传递参数，即可测试CRUD功能。

五、高频踩坑点汇总（新手必看，规避90%问题）

整理了新手实现单表CRUD时最常遇到的6个问题，每个问题附上根因和解决方案，遇到报错直接对照排查，快速解决。

踩坑1：Mapper注入失败（No qualifying bean of type ‘xxxMapper’ available）

✅ 报错原因：启动类未添加@MapperScan注解，或注解中的包路径错误；Mapper接口未添加@Mapper注解。

✅ 解决方案：启动类添加@MapperScan(“com.example.cruddemo.mapper”)；确保Mapper接口添加@Mapper注解；核对包路径，确保一致。

踩坑2：新增/修改后，时间字段未自动填充

✅ 报错原因：未编写时间自动填充处理器（MyMetaObjectHandler）；处理器未添加@Component注解，未被Spring管理；实体类字段的@TableField(fill = …)配置错误。

✅ 解决方案：编写MyMetaObjectHandler类，添加@Component注解；核对实体类字段的fill属性，insert对应INSERT，update对应INSERT_UPDATE。

踩坑3：修改数据无效，无报错

✅ 报错原因：修改时未设置实体类的id字段（MyBatis-Plus根据id修改）；实体类所有字段为null，无修改内容；数据库表主键不是id，或主键策略配置错误。

✅ 解决方案：修改时必须设置实体类的id；确保至少有一个非null字段需要修改；核对yml中mybatis-plus.global-config.db-config.id-type配置，与数据库主键策略一致。

踩坑4：条件查询无结果，SQL日志显示条件错误

✅ 报错原因：QueryWrapper构建条件时，字段名与数据库字段不一致；未开启下划线转驼峰配置，导致字段匹配失败（如createTime对应create_time）。

✅ 解决方案：QueryWrapper中使用数据库字段名（如name、age），而非实体类驼峰名；确保yml中开启map-underscore-to-camel-case: true。

踩坑5：Service注入失败（No qualifying bean of type ‘xxxService’ available）

✅ 报错原因：Service实现类未添加@Service注解；Service接口未继承IService，或实现类未继承ServiceImpl。

✅ 解决方案：Service实现类添加@Service注解；确保UserService继承IService，UserServiceImpl继承ServiceImpl<UserMapper, User>。

踩坑6：SQL日志不打印，无法调试

✅ 报错原因：未开启MyBatis-Plus的SQL日志打印配置；log-impl配置路径错误。

✅ 解决方案：在yml的mybatis-plus.configuration中，添加log-impl: org.apache.ibatis.logging.stdout.StdOutImpl。

六、补充：BaseMapper vs IService 选择建议

很多新手会纠结两种方式的选择，结合实际开发场景，给出明确建议，避免选型困惑：

• 新手入门、简单测试：优先使用BaseMapper，代码更简洁，无需编写Service层，快速实现CRUD；

• 实际项目开发：优先使用IService+ServiceImpl，封装服务层，便于添加自定义业务逻辑，支持批量操作、分页查询等增强功能，符合分层开发规范（Controller → Service → Mapper）；

• 核心区别：IService基于BaseMapper封装，功能更丰富，返回值更直观（如boolean表示操作结果），适合业务场景；BaseMapper更偏向底层，适合简单场景。

七、总结

Spring Boot + MyBatis-Plus 实现单表CRUD的核心，就是“复用MyBatis-Plus内置接口”，无需编写XML和SQL，极大简化了开发流程，核心步骤可总结为3步：

1. 准备工作：导入核心依赖、配置数据库连接、创建数据库表；

2. 核心编码：编写实体类（关联数据库表）、Mapper接口（继承BaseMapper）、Service层（可选，继承IService）；

3. 测试验证：通过测试类或接口，验证新增、查询、修改、删除功能正常。

本文覆盖了新手实现单表CRUD的全流程，从基础配置到进阶用法，从测试验证到踩坑排查，贴合实战场景，新手只需跟着步骤操作，就能快速上手。后续可基于此基础，学习MyBatis-Plus的高级特性（条件构造器、分页插件、自动生成代码），进一步提高开发效率。

若遇到其他问题，可对照本文踩坑点排查，或留言交流，助力你快速搞定单表CRUD开发！