Spring Boot + MyBatisPlus快速实现单表CRUD的示例

<!-- 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>

-- 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='用户表';

# 服务器配置（可选，避免端口冲突）
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自增对应）

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

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;
}

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());
    }
}

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方法
}

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);
    }

}

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已内置
}

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);
    }
    */
}

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);
    }
}

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);
    }
}

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);
    }
}