SpringBoot3 整合 MyBatis 与 Druid：企业级应用开发实战教程

在企业级 Java 开发中，SpringBoot 作为主流的开发框架，以自动配置、快速部署的特性大幅提升开发效率；MyBatis 作为优秀的持久层框架，支持自定义 SQL、存储过程，灵活适配复杂业务数据操作；Druid 作为阿里开源的数据库连接池，具备监控、防 SQL 注入、高性能等优势，是企业级应用的首选连接池。

本文将手把手带你实现SpringBoot3 + MyBatis + Druid的完整整合，从环境搭建到源码实战，覆盖企业级开发基础配置，代码可直接复用至生产项目。

一、技术选型说明

表格

技术框架	版本	核心作用
SpringBoot	3.2.x	项目容器、自动配置、依赖管理
MyBatis	3.5.x	持久层框架，操作数据库
MyBatis-Spring-Boot-Starter	3.0.x	MyBatis 与 SpringBoot 整合适配
Druid	1.2.20	数据库连接池、监控、性能优化
MySQL	8.0	关系型数据库

二、项目初始化与依赖配置

1. 创建 SpringBoot3 项目

通过 IDE（IDEA/Eclipse）创建 Maven/Gradle 项目，选择 SpringBoot3 版本，勾选基础依赖（Spring Web）。

2. 核心 Maven 依赖

打开pom.xml，添加整合所需的核心依赖，排除 SpringBoot 默认数据源，使用 Druid 替代：

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>3.2.5</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>springboot3-mybatis-druid</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot3-mybatis-druid</name>

    <properties>
        <java.version>17</java.version>
    </properties>

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

        <!-- MyBatis整合SpringBoot3依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>

        <!-- Druid连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-3-starter</artifactId>
            <version>1.2.20</version>
        </dependency>

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

        <!-- 测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

注意：SpringBoot3 最低支持 Java17，需确保开发环境为 JDK17 及以上。

三、数据库准备

创建测试数据库和用户表，用于后续 CRUD 实战：

sql

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

-- 使用数据库
USE springboot_demo;

-- 创建用户表
CREATE TABLE `sys_user` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `username` varchar(50) NOT NULL COMMENT '用户名',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统用户表';

-- 插入测试数据
INSERT INTO `sys_user` (username, password, phone) VALUES 
('admin','123456','13800138000'),
('test','654321','13900139000');

四、SpringBoot 核心配置文件

创建application.yml配置文件，配置数据源、Druid 连接池、MyBatis，这是企业级应用的标准配置：

yaml

# 服务端口配置
server:
  port: 8080

# 数据库与Druid连接池配置
spring:
  datasource:
    # 驱动类（MySQL8）
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库连接地址
    url: jdbc:mysql://localhost:3306/springboot_demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    # 数据库账号
    username: root
    # 数据库密码
    password: 你的数据库密码
    # 指定Druid连接池
    type: com.alibaba.druid.pool.DruidDataSource
    # Druid连接池核心配置（企业级优化）
    druid:
      # 初始化连接数
      initial-size: 5
      # 最小空闲连接数
      min-idle: 5
      # 最大活跃连接数
      max-active: 20
      # 获取连接等待超时时间（毫秒）
      max-wait: 60000
      # 检测空闲连接间隔时间（毫秒）
      time-between-eviction-runs-millis: 60000
      # 连接在池中的最小生存时间（毫秒）
      min-evictable-idle-time-millis: 300000
      # 测试连接是否有效的SQL
      validation-query: SELECT 1
      # 空闲时检测连接有效性
      test-while-idle: true
      # 获取连接时不检测有效性
      test-on-borrow: false
      # 归还连接时不检测有效性
      test-on-return: false
      # 开启监控统计功能
      stat-view-servlet:
        enabled: true
        # 监控页面访问地址
        url-pattern: /druid/*
        # 监控页面登录账号
        login-username: admin
        # 监控页面登录密码
        login-password: admin123
      # 开启SQL监控、防火墙功能
      filter:
        stat:
          enabled: true
          log-slow-sql: true
          slow-sql-millis: 1000
        wall:
          enabled: true

# MyBatis配置
mybatis:
  # 映射XML文件路径
  mapper-locations: classpath:mapper/*.xml
  # 实体类包路径（别名配置）
  type-aliases-package: com.example.entity
  # 开启驼峰命名转换（数据库下划线→实体类驼峰）
  configuration:
    map-underscore-to-camel-case: true
    # 控制台打印SQL（开发环境开启）
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

核心配置说明：

Druid 监控页面：启动项目后访问http://localhost:8080/druid，输入配置的账号密码即可查看连接池、SQL 执行状态；

驼峰命名转换：自动匹配数据库create_time与实体类createTime，无需手动映射。

五、项目结构搭建（企业级标准）

遵循 MVC 架构，创建标准化项目目录，便于后期维护：

plaintext

com.example
├── Springboot3MybatisDruidApplication.java  # 启动类
├── controller        # 控制层（接口请求处理）
│   └── UserController.java
├── service           # 业务逻辑层
│   ├── UserService.java
│   └── impl
│       └── UserServiceImpl.java
├── mapper            # 数据访问层（MyBatis Mapper）
│   └── UserMapper.java
├── entity            # 实体类（与数据库表映射）
│   └── User.java
└── resources
    └── mapper        # MyBatis XML映射文件
        └── UserMapper.xml

六、核心代码实现

1. 启动类配置

在启动类上添加@MapperScan注解，扫描 MyBatis 的 Mapper 接口：

java

运行

package com.example;

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

/**
 * SpringBoot启动类
 * @MapperScan：扫描Mapper接口所在包
 */
@SpringBootApplication
@MapperScan("com.example.mapper")
public class Springboot3MybatisDruidApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot3MybatisDruidApplication.class, args);
    }
}

2. 实体类（Entity）

创建与数据库表对应的实体类，使用 Lombok 简化代码（可自行添加 get/set 方法）：

java

运行

package com.example.entity;

import java.util.Date;

/**
 * 用户实体类
 */
public class User {
    // 主键ID
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 手机号
    private String phone;
    // 创建时间
    private Date createTime;

    // 无参构造
    public User() {}

    // Getter & Setter
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
    public Date getCreateTime() { return createTime; }
    public void setCreateTime(Date createTime) { this.createTime = createTime; }
}

3. 数据访问层（Mapper）

创建 MyBatis Mapper 接口，定义数据库操作方法：

java

运行

package com.example.mapper;

import com.example.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

/**
 * 用户Mapper接口
 */
@Mapper
public interface UserMapper {
    // 查询所有用户
    List<User> selectAllUser();

    // 根据ID查询用户
    User selectUserById(Long id);

    // 新增用户
    int insertUser(User user);

    // 修改用户
    int updateUser(User user);

    // 删除用户
    int deleteUserById(Long id);
}

4. MyBatis XML 映射文件

在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.mapper.UserMapper">

    <!-- 结果集映射 -->
    <resultMap id="BaseResultMap" type="User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="phone" property="phone"/>
        <result column="create_time" property="createTime"/>
    </resultMap>

    <!-- 查询所有用户 -->
    <select id="selectAllUser" resultMap="BaseResultMap">
        SELECT id, username, password, phone, create_time FROM sys_user
    </select>

    <!-- 根据ID查询用户 -->
    <select id="selectUserById" resultMap="BaseResultMap" parameterType="java.lang.Long">
        SELECT id, username, password, phone, create_time FROM sys_user WHERE id = #{id}
    </select>

    <!-- 新增用户 -->
    <insert id="insertUser" parameterType="User">
        INSERT INTO sys_user (username, password, phone)
        VALUES (#{username}, #{password}, #{phone})
    </insert>

    <!-- 修改用户 -->
    <update id="updateUser" parameterType="User">
        UPDATE sys_user
        SET username = #{username}, password = #{password}, phone = #{phone}
        WHERE id = #{id}
    </update>

    <!-- 删除用户 -->
    <delete id="deleteUserById" parameterType="java.lang.Long">
        DELETE FROM sys_user WHERE id = #{id}
    </delete>
</mapper>

5. 业务逻辑层（Service）

5.1 Service 接口

java

运行

package com.example.service;

import com.example.entity.User;
import java.util.List;

/**
 * 用户业务接口
 */
public interface UserService {
    // 查询所有用户
    List<User> getAllUser();

    // 根据ID查询用户
    User getUserById(Long id);

    // 新增用户
    boolean addUser(User user);

    // 修改用户
    boolean updateUser(User user);

    // 删除用户
    boolean deleteUser(Long id);
}

5.2 Service 实现类

java

运行

package com.example.service.impl;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import com.example.service.UserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;

/**
 * 用户业务实现类
 */
@Service
public class UserServiceImpl implements UserService {

    // 注入Mapper接口
    @Resource
    private UserMapper userMapper;

    @Override
    public List<User> getAllUser() {
        return userMapper.selectAllUser();
    }

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

    @Override
    public boolean addUser(User user) {
        return userMapper.insertUser(user) > 0;
    }

    @Override
    public boolean updateUser(User user) {
        return userMapper.updateUser(user) > 0;
    }

    @Override
    public boolean deleteUser(Long id) {
        return userMapper.deleteUserById(id) > 0;
    }
}

6. 控制层（Controller）

编写 RESTful 接口，提供前端调用的 HTTP 接口：

java

运行

package com.example.controller;

import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

/**
 * 用户控制层
 */
@RestController
@RequestMapping("/user")
public class UserController {

    // 注入Service
    @Resource
    private UserService userService;

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

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

    // 新增用户
    @PostMapping("/add")
    public String addUser(@RequestBody User user) {
        return userService.addUser(user) ? "新增成功" : "新增失败";
    }

    // 修改用户
    @PutMapping("/update")
    public String updateUser(@RequestBody User user) {
        return userService.updateUser(user) ? "修改成功" : "修改失败";
    }

    // 删除用户
    @DeleteMapping("/delete/{id}")
    public String deleteUser(@PathVariable Long id) {
        return userService.deleteUser(id) ? "删除成功" : "删除失败";
    }
}

七、项目启动与功能测试

1. 启动项目

运行Springboot3MybatisDruidApplication.java启动类，控制台无报错则说明整合成功。

2. Druid 监控测试

访问地址：http://localhost:8080/druid，输入配置的账号admin/ 密码admin123，即可查看：

数据库连接池状态
SQL 执行监控、慢 SQL 统计
防火墙、URL 监控等

3. 接口测试

使用 Postman、ApiPost 等工具测试接口，示例：

查询所有用户：GET http://localhost:8080/user/list
新增用户：POST http://localhost:8080/user/add，请求体：

json

{
    "username": "springboot",
    "password": "123123",
    "phone": "13700137000"
}

其他接口可按照对应请求方式测试。

八、企业级开发核心要点

配置分离：生产环境将数据库账号密码、端口等配置放入环境变量，避免硬编码；
Druid 优化：根据服务器配置调整连接数，开启慢 SQL 监控，及时优化性能瓶颈；
MyBatis 最佳实践：使用 XML 编写复杂 SQL，注解编写简单 SQL，开启驼峰命名，避免字段映射错误；
事务管理：业务层添加@Transactional注解，保证数据一致性；
日志管理：生产环境关闭 SQL 打印，使用 SLF4J+Logback 记录系统日志。

九、总结

本文完整实现了 SpringBoot3 与 MyBatis、Druid 的企业级整合，从依赖配置、数据库设计到代码实战，覆盖了 Java 后端开发的基础核心流程。

SpringBoot3 简化了框架整合配置，MyBatis 保证了数据操作的灵活性，Druid 提供了可靠的数据库连接管理与监控能力，三者结合是企业级 Java 应用开发的经典方案，适合中小型项目、大型微服务项目使用。

源码结构清晰、配置标准化，可直接作为企业级项目的基础框架进行二次开发，快速落地业务需求。

一、技术选型说明

二、项目初始化与依赖配置

1. 创建 SpringBoot3 项目

2. 核心 Maven 依赖

三、数据库准备

四、SpringBoot 核心配置文件

五、项目结构搭建（企业级标准）

六、核心代码实现

1. 启动类配置

2. 实体类（Entity）

3. 数据访问层（Mapper）

4. MyBatis XML 映射文件

5. 业务逻辑层（Service）

5.1 Service 接口

5.2 Service 实现类

6. 控制层（Controller）

七、项目启动与功能测试

1. 启动项目

2. Druid 监控测试

3. 接口测试

八、企业级开发核心要点

九、总结

相关文章