Spring Boot 3 【七】万字详解：整合 MyBatis Plus 实现增删改查

在 Java 开发中，Spring Boot 和 MyBatis Plus 都是非常强大的工具。Spring Boot 简化了 Spring 应用的开发，而 MyBatis Plus 则在 MyBatis 的基础上进行了增强，提供了更多便捷的功能。本文将详细介绍如何使用 Spring Boot 3.3、JDK 17 整合 MyBatis Plus 实现数据库的增删改查操作，适合初学者学习。

一、组件简介

（一）Spring Boot 3.3

Spring Boot 3.3 是一个用于快速开发 Spring 应用的框架。它简化了 Spring 应用的配置，提供了自动配置、起步依赖等功能，使得开发者可以更加专注于业务逻辑的实现。Spring Boot 3.3 带来了一些新的特性和改进，如更好的性能、更强大的安全性等。

（二）MyBatis Plus

MyBatis Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。它提供了很多实用的功能，如通用 CRUD 操作、分页插件、代码生成器等。

（三）JDK 17

JDK 17 是 Java 开发工具包的一个版本，带来了许多新的特性和改进，如增强的安全性、更好的性能等。

（四）Eclipse 2023-03

Eclipse 是一个流行的 Java 开发工具，本文使用 Eclipse 2023-03 版本，该版本提供了许多新的功能和改进，如更好的性能、更强大的调试功能等。

二、环境准备

（一）安装 JDK 17

1. 从 Oracle 官网下载 JDK 17 的安装包。
2. 运行安装包，按照提示进行安装。
3. 配置环境变量，将 JDK 17 的安装路径添加到系统的环境变量中。

详请看此文：Java核心技术【二】Win10安装Java 配置环境变量

（二）安装 Eclipse 2023-03

• 从 Eclipse 官网下载 Eclipse 2023-03 的安装包。
• 运行安装包，按照提示进行安装。

（三）创建 Maven 项目

• 打开 Eclipse，选择 “File” -> “New” -> “Other”。
• 在弹出的窗口中，选择 “Maven” -> “Maven Project”。
• 点击 “Next”，选择 “Create a simple project”。
• 填写项目的基本信息：groupId、artifactId、version和打包方式。 点击 “Finish” 完成项目的创建。

（四）项目结构

• src/main/java/com/jsglxx/demo：这是项目的主要代码目录。
  • model 包：包含了数据库表的实体类。
  • mapper 包：包含了数据库操作的 Mapper 接口。
  • service 包：包含了业务逻辑的 Service 接口和实现类。
  • controller 包：包含了 RESTful API 的 Controller 类。
• src/main/resources：这是项目的资源目录。
  • application.yml：项目的配置文件，用于配置数据库连接等信息。

三、添加依赖

（一）在 pom.xml 文件中添加依赖

在创建的 Maven 项目的 pom.xml 文件中添加以下依赖：

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.2</version>
        <relativePath/> 
  </parent>
  
  <dependencies> 
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-thymeleaf</artifactId>  
		</dependency>  
    <dependency>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-web</artifactId>  
		</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<scope>runtime</scope>
		<version>8.0.33</version>
	</dependency>
	<dependency>
	    <groupId>com.baomidou</groupId>
	    <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
	    <version>3.5.7</version>
	</dependency>

	<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-aop</artifactId>
	</dependency>
	<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

注意：
一定要导入 mybatis-plus-spring-boot3-starter 包，而非 mybatis-plus-boot-starter 包，Springboot 3 有所区别，否则会因兼容性问题，报如下异常：
java.lang.IllegalArgumentException: Invalid value type for attribute ‘factoryBeanObjectType’: java.lang.String

四、配置数据库连接

（一）在 application.yml 文件配置

在项目的 src/main/resources 目录下创建一个 application.yml 文件，并添加以下配置：

server:
  port:8080
#配置mysql数据库连接
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/spring_boot_jpa?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    
#mp配置
mybatis-plus:
  #配置xml文件路径
  mapper-locations: classpath:/mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true
    #打印sql日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      #id自增类型配置
      id-type: ASSIGN_ID
      #逻辑删除字段配置
      logic-delete-field: deleted
      logic-not-delete-value: 0
      logic-delete-value: 1
    #控制台mybatis-plus标记
    banner: true

（二）创建数据库表

在 MySQL 数据库中创建一个名为 user 的表，表结构如下：

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

五、创建实体类

（一）创建 User 类

在项目的 src/main/java/com/jsglxx/demo/model 包下创建一个名为 User.java 的类，作为数据库表的实体类：

package com.jsglxx.demo.model;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

@TableName("user")
public class User{  
	@TableId
    private long id;  
    private String name;  
    private String email;
	//省略 getter、setter、构造方法

}

1. @TableName(“user”)： 这个注解用于指定该类映射的数据库表名。在默认情况下，MyBatis Plus 会根据实体类的名称（将类名的首字母大写，例如 User 类会映射到 User
   表）来寻找对应的数据库表。如果表名与类名不一致，或者你想自定义表名，就可以使用 @TableName 注解。在这个例子中，@TableName(“user”) 表示 User 类映射到数据库中的 user 表。
2. @TableId：
   这个注解用于指定实体类中的主键字段。在默认情况下，MyBatis Plus 会寻找名为 id 的字段作为主键。如果你的主键字段名不是 id，或者你需要对主键字段进行额外的配置（例如指定主键生成策略），就可以使用 @TableId 注解。在这个例子中，@TableId 注解表明 id 字段是 user 表的主键。
3. 额外说明：
   • 主键生成策略：@TableId 注解还可以指定主键的生成策略，例如使用 @TableId(type = IdType.AUTO) 来指定主键为自动增长类型。默认情况下，type 属性是 IdType.NONE，表示不使用任何主键生成策略，需要手动输入主键值。
   • 字段映射：如果实体类的字段名和数据库表的列名不一致，可以使用 @TableField 注解来指定字段和列之间的映射关系。

六、创建 Mapper 接口

（一）创建 UserMapper 接口

在项目的 src/main/java/com/jsglxx/demo/mapper 包下创建一个名为 UserMapper.java 的接口，继承 BaseMapper 接口：

package com.jsglxx.demo.mapper;


import org.apache.ibatis.annotations.Mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jsglxx.demo.model.User;

@Mapper
public interface UserMapper extends BaseMapper<User>{
	// 这里可以添加自定义的查询方法，如果不需要，可以为空
}

这里继承了 BaseMapper 接口，就可以使用 MyBatis Plus 提供的通用 CRUD 方法了，常用的已经帮我们实现了，我们只需要调用即可。

（二） BaseMapper 源码分析

部分源码如下：

public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    default int deleteById(Serializable id) {
        return deleteById(id, true);
    }

    /**
     * 根据 ID 删除
     *
     * @param useFill 是否填充
     * @param obj      主键ID或实体
     * @since 3.5.7
     */
    default int deleteById(Object obj, boolean useFill) {
        Class<?> entityClass = GenericTypeUtils.resolveTypeArguments(getClass(), BaseMapper.class)[0];
        if (!entityClass.isAssignableFrom(obj.getClass()) && useFill) {
            TableInfo tableInfo = TableInfoHelper.getTableInfo(entityClass);
            if (tableInfo.isWithLogicDelete() && tableInfo.isWithUpdateFill()) {
                T instance = tableInfo.newInstance();
                tableInfo.setPropertyValue(instance, tableInfo.getKeyProperty(), OgnlOps.convertValue(obj, tableInfo.getKeyType()));
                return this.deleteById(instance);
            }
        }
        MybatisMapperProxy<?> mybatisMapperProxy = MybatisUtils.getMybatisMapperProxy(this);
        SqlSession sqlSession = mybatisMapperProxy.getSqlSession();
        return sqlSession.delete(mybatisMapperProxy.getMapperInterface().getName() + Constants.DOT + SqlMethod.DELETE_BY_ID.getMethod(), obj);
    }

• 在实际应用中，MyBatis-Plus 会根据 UserMapper 接口生成一个实现类，并通过这个实现类与数据库进行交互。这个实现类通常是在运行时通过动态代理或者代码生成技术创建的。
• 当调用 UserMapper 中的方法时，MyBatis-Plus 会拦截这些方法调用，并根据方法的签名和参数生成相应的 SQL 语句，然后执行 SQL 语句并返回结果。 例如，当调用 userMapper.insert(user) 时，MyBatis-Plus 会生成一个插入 SQL 语句，将 user 对象的属性值作为参数绑定到 SQL 语句中，然后执行插入操作，并返回插入后的记录数量或者其他相关信息。
• UserMapper 接口继承了 BaseMapper，这使它可以直接使用BaseMapper 中定义的通用方法。同时，开发人员可以在 UserMapper 中添加自定义的方法，以满足特定的业务需求。例如，可以添加一个根据用户名查询用户的方法：

   public interface UserMapper extends BaseMapper<User> {
       User selectByUsername(String username);
   }

七、创建 Service 接口和实现类

（一）创建 UserService 接口

在项目的 src/main/java/com/jsglxx/demo/service 包下创建一个名为 UserService.java 的接口，定义基本的增删改查方法：

package com.jsglxx.demo.service;

import java.util.List;

import com.jsglxx.demo.model.User;

public interface UserService {
    int insert(User user);
    int update(User user);
    int deleteById(Long id);
    User selectById(Long id);
    List<User> selectList();
}

（二）创建 UserServiceImpl 实现类

在项目的 src/main/java/com/jsglxx/demo/service 包下创建一个名为 UserServiceImpl.java 的类，实现 UserService 接口：

package com.jsglxx.demo.service;

import java.util.List;

import org.springframework.stereotype.Service;

import com.jsglxx.demo.model.User;

import jakarta.annotation.Resource;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jsglxx.demo.mapper.UserMapper;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    @Resource
	private UserMapper userMapper;
	@Override
    public int insert(User user) {
        return userMapper.insert(user);
    }

    @Override
    public int update(User user) {
        return userMapper.updateById(user);
    }

    @Override
    public int deleteById(Long id) {
        return userMapper.deleteById(id);
    }

    @Override
    public User selectById(Long id) {
        return userMapper.selectById(id);
    }

    @Override
    public List<User> selectList() {
        return userMapper.selectList(null);
    }
}

这里使用了 ServiceImpl 类来简化 Service 层的实现，继承了 ServiceImpl 类后，就可以直接使用 MyBatis Plus 提供的通用 CRUD 方法了。

八、创建 Controller 类

（一）创建 UserController 类

在项目的 src/main/java/com/jsglxx/demo/controller 包下创建一个名为 UserController.java 的类：

package com.jsglxx.demo.controller;
import com.jsglxx.demo.model.User;
import com.jsglxx.demo.service.UserService;

import jakarta.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.*;  
  
import java.util.*;  

@RestController  
@RequestMapping("/users")  
public class UserController {  
	
		@Resource
	    private UserService userService;

	    @PostMapping
	    public int insert(@RequestBody User user) {
	        return userService.insert(user);
	    }

	    @PutMapping
	    public int update(@RequestBody User user) {
	        return userService.update(user);
	    }

	    @DeleteMapping("/{id}")
	    public int deleteById(@PathVariable Long id) {
	        return userService.deleteById(id);
	    }

	    @GetMapping("/{id}")
	    public User selectById(@PathVariable Long id) {
	        return userService.selectById(id);
	    }

	    @GetMapping
	    public List<User> selectList() {
	        return userService.selectList();
	    }
}

这里创建了一个 RESTful API，用于对用户进行增删改查操作。通过 @Autowired 注解注入了 UserService，然后在各个方法中调用 UserService 的方法来实现具体的业务逻辑。

九、测试

（一）启动应用

在 Eclipse 中，右键点击项目的主类，选择 “Run As” -> “Java Application” 来启动应用。

（二）使用 Postman 进行测试

1. 插入用户

• 使用 Postman 发送一个 POST 请求到 http://localhost:8080/users，请求体为一个 JSON对象，包含用户的信息，如 { “name”: “张三”, “email”: “zhangsan@jsglxx.com” }。
• 查看响应结果，应该返回插入的用户数量，通常为 1。

控制台显示打印sql:

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6820653f] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1726449227 wrapping com.mysql.cj.jdbc.ConnectionImpl@34f94e7c] will not be managed by Spring
==>  Preparing: INSERT INTO user ( id, name, email ) VALUES ( ?, ?, ? )
==> Parameters: 0(Long), 张三(String), zhangsan@jsglxx.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6820653f]

user 表中也有了数据：

2. 查询用户列表

• 使用 Postman 发送一个 GET 请求到 http://localhost:8080/users。
• 查看响应结果，应该返回一个包含所有用户的 JSON 数组。
  

3. 查询单个用户

• 使用 Postman 发送一个 GET 请求到 http://localhost:8080/users/{id}，其中 {id} 为要查询的用户的 ID。
• 查看响应结果，应该返回一个包含用户信息的 JSON 对象。
  

4. 更新用户

• 使用 Postman 发送一个 PUT 请求到 http://localhost:8080/users，请求体为一个 JSON 对象，包含要更新的用户信息，如 { “id”: 5, “name”: “张五”, “email”: “zhangwu@qq.com” }。
• 查看响应结果，应该返回更新的用户数量，通常为 1。
  

6. 删除用户

• 使用 Postman 发送一个 DELETE 请求到 http://localhost:8080/users/{id}，其中 {id} 为要删除的用户的 ID。
• 查看响应结果，应该返回删除的用户数量，通常为 1。
  

十、总结

通过本文的介绍，你应该已经了解了如何使用 Spring Boot 3.3、JDK 17 版本整合 MyBatis Plus 实现数据库的增删改查操作。Spring Boot 和 MyBatis Plus 都是非常强大的工具，它们的结合可以大大提高开发效率。在实际开发中，你可以根据自己的需求进行更多的定制和扩展，如使用分页插件、条件查询等。希望本文对你有所帮助。

遇见即是缘分，关注🌟、点赞👍、收藏📚，让这份美好延续下去！

🌟 对技术管理感兴趣 请关注下方 ⬇ 【 技术管理修行】