第一期：[特殊字符] 深入理解MyBatis[特殊字符]从JDBC到MyBatis——持久层开发的转折点[特殊字符]

前言

在软件开发的过程中，持久层（或数据访问层）是与数据库进行交互的关键部分。早期，开发者通常使用 JDBC（Java Database Connectivity）来实现与数据库的连接与操作。虽然 JDBC 在一定程度上简化了数据库操作，但它仍然存在许多挑战和不便之处，比如 SQL 语句的硬编码、结果集的处理复杂度、以及代码的冗长和重复性等问题。

随着时间的推移，开发者们意识到，JDBC 无法完全满足高效、灵活、易维护的开发需求，尤其是在面对复杂的业务逻辑时。于是，MyBatis 作为一种解决方案应运而生，填补了 JDBC 的空白，极大地简化了数据库操作的复杂性。

MyBatis 不仅提供了强大的 SQL 映射功能，还能让开发者专注于业务逻辑，避免了大量的重复代码编写。与 JDBC 相比，它的优势在于支持动态 SQL、映射文件的配置、与 POJO（Plain Old Java Object）之间的映射等，使得持久层的开发更加灵活、高效且易于维护。⚙️

在这一篇文章中，我们将详细探讨从 JDBC 到 MyBatis 的过渡，并分析两者之间的差异与优劣。

---

从 JDBC 到 MyBatis —— 为什么是转折点？

1. JDBC 的痛点

   • SQL 与 Java 代码耦合度高，难以维护。

   • 操作繁琐，需要大量手动编写的代码（例如，连接管理、异常处理、结果集映射）。

   • 难以进行灵活的动态 SQL 构建。

2. MyBatis 的优势

   • SQL 映射：通过 XML 或注解的方式，将 SQL 语句与 Java 方法进行映射，减少了代码冗余。

   • 动态 SQL：MyBatis 提供了强大的动态 SQL 功能，能够根据不同条件动态生成 SQL 语句。

   • 分离 SQL 与 Java：通过配置文件或者注解方式，可以轻松将 SQL 与 Java 代码进行解耦，便于管理和维护。

MyBatis 的引入使得持久层开发的工作更加专注于业务逻辑，而不是被琐碎的 SQL 语句和数据库交互所困扰。

---

接下来的章节将带你深入了解如何使用 MyBatis 进行高效的持久层开发，帮助你从 JDBC 迈向更为现代和灵活的数据库操作方式。

如果你对 MyBatis 感兴趣，那就继续跟随我们一起探索吧！

---

1. 背景与痛点分析

在开发过程中，持久层（数据访问层）是应用程序与数据库之间的重要桥梁。在传统的 JDBC 开发中，开发者需要手动编写大量的数据库连接、查询、更新等操作，这使得开发流程显得非常繁琐且容易出错。让我们来回顾一下 JDBC 开发流程，并分析其面临的痛点。

传统 JDBC 开发流程

1. 数据库连接：

   • 每次操作数据库时，开发者需要手动创建数据库连接。

   • 需要配置数据库的连接信息（URL、用户名、密码等），并确保连接成功。

2. 执行 SQL 语句：

   • 手动编写 SQL 查询语句（SELECT、INSERT、UPDATE、DELETE），并在代码中将其硬编码。

   • 使用 Statement 或 PreparedStatement 对象执行 SQL 语句，并返回结果。

3. 结果集处理：

   • 使用 ResultSet 对象获取查询结果，手动处理数据的转换和映射。

   • 如果查询结果较为复杂，可能需要多次遍历和处理。

4. 资源管理：

   • 开发者需要手动关闭数据库连接、Statement 和 ResultSet 对象，以避免资源泄漏。

   • 需要特别小心在异常发生时正确释放资源，容易导致内存泄漏或数据库连接池过载。

5. 异常处理：

   • 需要对数据库操作进行大量的异常捕获和处理，通常会涉及 SQL 异常、连接超时等各种问题。

这些步骤看似简单，但实际上每一个步骤都需要额外的代码支持，且容易出现重复。

痛点分析

• 繁琐的代码：每个数据库操作都需要手动编写大量的代码，这些代码不仅冗长，而且容易出错。尤其是连接的管理和结果集的处理，都需要开发者手动完成。

• 重复的代码：不同的操作（如增、删、改、查）虽然只是细节不同，但需要的代码非常相似，导致大量重复代码的存在。每个操作的 SQL 语句、数据库连接、关闭资源等步骤都需要重复编写。

• 资源管理复杂：开发者需要时刻关注连接、Statement、ResultSet 等资源的关闭和释放。由于操作数据库时常常会出现异常，处理这些资源时容易漏掉，从而导致数据库连接泄漏和性能问题。

• SQL 和 Java 代码耦合：SQL 语句通常硬编码在 Java 代码中，导致 SQL 的修改需要重新编译 Java 代码。而且，复杂的 SQL 语句与 Java 代码的混合，使得代码难以阅读、维护和扩展。

• 难以维护：随着项目的增长，JDBC 代码逐渐变得冗长且复杂。如果业务需求发生变化，需要修改 SQL 或数据库操作时，可能需要修改多个地方，容易引入错误。

---

引入持久层概念及 DAO 设计思想 ️

为了解决传统 JDBC 开发中的这些痛点，持久层（Persistence Layer） 的概念应运而生。持久层的核心思想是将与数据库相关的操作封装成独立的模块，提供对数据库的统一接口，从而让业务逻辑与数据库操作分离。

DAO（Data Access Object）设计模式

DAO 设计模式是一种常见的解决方案，它通过提供数据访问对象，将数据库操作与业务逻辑隔离开来，达到以下目标：

• 封装数据库操作：将所有数据库的增删改查操作集中在一个 DAO 类中，业务逻辑只需要与 DAO 对象交互，不需要关心底层的数据库细节。

• 统一接口：DAO 提供统一的接口，方便维护和扩展。业务逻辑与数据库操作之间的耦合度降低，便于修改数据库实现（如更换数据库系统）。

• 简化代码结构：DAO 模式将数据库操作代码封装，避免了大量重复的数据库访问代码，提升了代码的可读性和可维护性。

• 易于扩展和维护：随着需求的增加或数据库结构的变化，修改数据库相关代码时，只需更新 DAO 层，而不必改变业务逻辑代码。

为什么需要更高效的解决方案？

传统的 JDBC 开发虽然可以完成数据库操作，但它无法满足以下需求：

• 开发效率：手动管理数据库连接、资源释放和异常处理的繁琐操作，大大降低了开发效率。

• 代码可维护性：冗长、重复且耦合的代码难以维护和扩展。

• 灵活性与可扩展性：当业务需求发生变化时，修改 SQL 或数据库操作变得困难且容易出错。

因此，持久层 和 DAO 设计模式为解决这些问题提供了更高效的解决方案。通过引入 MyBatis 或类似框架，我们可以进一步简化数据库操作，避免重复代码，提高开发效率和代码的可维护性。

---

2. 什么是 MyBatis

MyBatis 是一个用于简化数据库操作的 持久层框架，它使得 Java 程序能够更加高效地与数据库进行交互。MyBatis 通过 SQL 映射 的方式，将 SQL 语句与 Java 方法进行关联，从而避免了传统 JDBC 中繁琐的数据库操作。MyBatis 的设计理念是提供更大的灵活性，允许开发者自由编写 SQL 语句的同时，又能享受框架带来的便利。

---

MyBatis 的发展历程与框架定位 ️

1. 初始版本（iBatis）

• iBatis 是 MyBatis 的前身，它最早由 Clinton Begin 于 2002 年创建，并作为一个开源项目发布。iBatis 的初衷是简化数据库交互，尤其是帮助开发者避免过多的 JDBC 代码。

• iBatis 提供了一个映射框架，使得开发者可以通过 XML 配置文件来将 Java 对象和 SQL 语句进行映射。这种方式使得开发者可以将 SQL 语句与 Java 代码分离，从而提高了代码的可维护性。

2. MyBatis 的诞生

• 在 2010 年，iBatis 进行了一个重要的版本更新，之后该项目更名为 MyBatis。这个改名不仅代表了技术的进步，还为 MyBatis 带来了更多的功能增强和社区支持。

• MyBatis 的目标是进一步简化数据库操作，并且更加关注于 SQL 映射 和 Java 对象映射，从而让开发者能够更加灵活地控制数据库操作，同时减少数据库访问代码的复杂性。

3. 框架定位

• 轻量级框架：MyBatis 是一个轻量级框架，能够灵活地与任何类型的 Java 应用程序一起使用。它不仅支持传统的单机应用，也能与分布式系统、微服务架构等搭配使用。

• SQL 映射框架：MyBatis 的最大特色就是 SQL 映射机制，它允许开发者自定义 SQL 语句，并将其与 Java 方法进行绑定。与 Hibernate 等 ORM 框架相比，MyBatis 更加直接地让开发者控制 SQL，从而提供了更大的灵活性。

• 解耦 SQL 和 Java 代码：MyBatis 通过 XML 配置文件或注解的方式，将 SQL 语句从 Java 代码中分离开来，使得 SQL 可以独立进行管理和优化。这样既有利于 SQL 语句的重用，又提升了代码的可维护性。

---

与传统 JDBC 相比，MyBatis 如何通过映射机制简化数据库操作

1. 避免繁琐的 JDBC 代码 ⚙️

在传统的 JDBC 开发中，开发者需要手动管理数据库连接、执行 SQL 语句、处理结果集以及关闭各种资源。这些步骤都需要大量的代码，并且容易出错。

而 MyBatis 通过 SQL 映射机制，简化了这些步骤。开发者只需定义映射文件或注解来关联 SQL 语句和 Java 方法，框架会自动处理数据库连接、资源管理等细节。

传统 JDBC 示例：

Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");
PreparedStatement statement = connection.prepareStatement("SELECT * FROM users WHERE id = ?");
statement.setInt(1, userId);
ResultSet resultSet = statement.executeQuery();

while (resultSet.next()) {
    User user = new User();
    user.setId(resultSet.getInt("id"));
    user.setName(resultSet.getString("name"));
    // 处理其他字段
}

resultSet.close();
statement.close();
connection.close();

MyBatis 示例：

@Select("SELECT * FROM users WHERE id = #{userId}")
User getUserById(int userId);

可以看到，MyBatis 通过注解或者映射文件，将 SQL 语句直接与 Java 方法绑定，省去了手动写 SQL 连接、资源管理和结果集处理的麻烦。

2. SQL 与 Java 代码分离 ️

在传统的 JDBC 中，SQL 语句是嵌入在 Java 代码中的，这样的耦合使得 SQL 语句的修改需要重新编译 Java 代码。而在 MyBatis 中，SQL 语句和 Java 代码是分离的，可以放在独立的 XML 配置文件中。这样，SQL 的修改无需重新编译 Java 代码，大大提高了灵活性和可维护性。

MyBatis 配置示例（XML）：

    
        SELECT * FROM users WHERE id = #{userId}
    

这样，SQL 语句可以与 Java 代码完全分离，便于后期的维护和优化。

3. 动态 SQL 支持

MyBatis 通过 , , 等标签，支持灵活的动态 SQL。开发者可以根据条件动态构建 SQL 语句，而不需要手动拼接字符串，避免了 SQL 注入和冗余代码的问题。

动态 SQL 示例：

    SELECT * FROM users
    
        AND name = #{name}
        AND age = #{age}
    

通过动态 SQL，开发者可以更加灵活地处理复杂的查询需求，同时提高代码的可读性。

4. 简化的映射机制 ️

在 JDBC 中，开发者需要手动将查询结果从 ResultSet 转换为 Java 对象，这通常涉及大量的代码编写。而 MyBatis 提供了 映射器 功能，可以将查询结果自动映射到 Java 对象中，从而大大简化了对象的转换过程。

MyBatis 映射示例：

@Select("SELECT * FROM users WHERE id = #{userId}")
@ResultMap("userResultMap")
User getUserById(int userId);

MyBatis 会自动将查询结果转换为对应的 User 对象，无需手动处理每个字段的映射，极大地提高了开发效率和代码的简洁性。

---

总结

与传统的 JDBC 开发相比，MyBatis 通过 SQL 映射机制简化了数据库操作，避免了繁琐的 JDBC 代码，提升了开发效率和代码可维护性。它通过提供灵活的映射方式、动态 SQL 支持以及 SQL 与 Java 代码的分离，成为了数据库交互中一个强大而灵活的解决方案。

通过 MyBatis，开发者可以更加专注于业务逻辑，而不必为繁琐的数据库操作所困扰。

---

3. ⚙️ MyBatis 环境准备与配置 ️

在这一部分，我们将展示如何在 Spring Boot 项目中集成 MyBatis 并进行基本的配置。同时，我们将以一个简单的示例（如软书架和用户表）来说明如何使用 MyBatis 进行数据操作。

---

1. 创建 Spring Boot 工程，添加 MyBatis 和 MySQL 依赖

首先，你需要创建一个 Spring Boot 项目。如果你使用的是 Spring Initializr，可以选择以下依赖项：

• Spring Web

• Spring Data JPA

• MyBatis Framework

• MySQL Driver

如果你是通过手动配置的方式创建项目，接下来的步骤是将 MyBatis 和 MySQL 相关的依赖添加到 pom.xml（Maven）或 build.gradle（Gradle）中。

Maven 配置：

在 pom.xml 中添加如下依赖：

    
    
        org.springframework.boot
        spring-boot-starter-web
    
    
    
    
        org.springframework.boot
        spring-boot-starter-data-jpa
    
    
    
    
        org.mybatis.spring.boot
        mybatis-spring-boot-starter
        2.2.0
    

    
    
        mysql
        mysql-connector-java
    

    
    
        org.springframework.boot
        spring-boot-starter-logging
    

Gradle 配置：

如果你使用 Gradle，则在 build.gradle 文件中添加如下依赖：

dependencies {
    // Spring Boot Starter Web
    implementation 'org.springframework.boot:spring-boot-starter-web'

    // Spring Boot Starter for MySQL
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

    // MyBatis Spring Boot Starter
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.0'

    // MySQL JDBC Driver
    implementation 'mysql:mysql-connector-java'

    // Spring Boot Starter Logging (Optional)
    implementation 'org.springframework.boot:spring-boot-starter-logging'
}

---

2. 数据库连接配置及 MyBatis 日志配置

在 Spring Boot 中，我们通常在 application.yml 或 application.properties 文件中进行数据库连接和日志配置。

配置 application.yml 文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/bookstore?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root123
    driver-class-name: com.mysql.cj.jdbc.Driver
  mybatis:
    mapper-locations: classpath:mapper/*.xml
    type-aliases-package: com.example.demo.model
    configuration:
      map-underscore-to-camel-case: true
  logging:
    level:
      org.mybatis: DEBUG  # 启用 MyBatis SQL 日志
      org.springframework.jdbc.core: DEBUG  # 启用 Spring JDBC 日志

配置 application.properties 文件

如果你使用的是 application.properties 文件，可以按以下方式配置：

spring.datasource.url=jdbc:mysql://localhost:3306/bookstore?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.demo.model
mybatis.configuration.map-underscore-to-camel-case=true

logging.level.org.mybatis=DEBUG
logging.level.org.springframework.jdbc.core=DEBUG

在配置中：

• spring.datasource 用于设置数据库连接的 URL、用户名、密码等信息。

• mybatis.mapper-locations 配置了 MyBatis 映射文件的位置，这里假设映射文件存放在 classpath:mapper 目录下。

• mybatis.type-aliases-package 配置了实体类所在的包路径。

• mybatis.configuration.map-underscore-to-camel-case 设置是否支持数据库字段和实体类属性之间的下划线和驼峰命名法的自动转换。

• logging.level.org.mybatis 和 logging.level.org.springframework.jdbc.core 用于启用 SQL 日志，帮助开发者调试 SQL 查询。

---

3. 构建简单数据表（如软书架和用户表）并分析实体类与数据库字段如何映射

在数据库中，我们构建一个简单的用户表（users）以及软书架表（bookshelf）。这将帮助我们了解 MyBatis 如何通过映射机制将数据库字段与实体类的属性进行映射。

SQL 表结构 ️

1. 用户表（users）：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

1. 软书架表（bookshelf）：

CREATE TABLE bookshelf (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT,
    book_title VARCHAR(255) NOT NULL,
    book_author VARCHAR(255),
    added_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

实体类与数据库字段的映射 ‍

接下来，我们来创建两个实体类：User 和 Bookshelf。

1. User 实体类：

package com.example.demo.model;

import java.time.LocalDateTime;

public class User {
    private Integer id;
    private String username;
    private String password;
    private String email;
    private LocalDateTime createdAt;

    // Getters and Setters
}

1. Bookshelf 实体类：

package com.example.demo.model;

import java.time.LocalDateTime;

public class Bookshelf {
    private Integer id;
    private Integer userId;
    private String bookTitle;
    private String bookAuthor;
    private LocalDateTime addedDate;

    // Getters and Setters
}

分析映射

• 字段映射：MyBatis 会根据 @Param 注解或 XML 配置文件中定义的 #{} 占位符，自动将查询结果中的数据库字段映射到实体类的属性。

• 驼峰命名法与下划线转换：如果我们启用了 map-underscore-to-camel-case 配置项，MyBatis 会自动将数据库中的 created_at 映射为 Java 实体类中的 createdAt，这避免了手动转换字段名的麻烦。

MyBatis 映射文件（XML）示例

对于 User 和 Bookshelf 表，我们可以定义如下的 MyBatis 映射文件：

    
        
        
        
        
        
    

    
        SELECT * FROM users WHERE id = #{id}
    

DAO 接口 ‍

在 Spring Boot 中，我们通常会为每个实体创建一个对应的 DAO 接口来执行数据库操作：

package com.example.demo.mapper;

import com.example.demo.model.User;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectUserById(int id);
}

---

总结

通过本节的学习，我们成功地在 Spring Boot 中配置了 MyBatis 并与 MySQL 数据库连接。我们创建了简单的 User 和 Bookshelf 表，并展示了如何通过 MyBatis 映射机制将数据库字段与 Java 实体类属性进行自动映射。这一过程简化了传统 JDBC 开发中的繁琐操作，极大提高了开发效率和代码可维护性。

---

4. JDBC 与 MyBatis 编程模型对比代码示例

在这部分，我们将通过代码示例对比传统的 JDBC 编程和 MyBatis 编程模型。我们将使用一个简单的查询操作（查询用户信息）来展示两者的区别。

1. JDBC 编程模型 ⚙️

在传统的 JDBC 中，开发者需要手动处理数据库连接、执行 SQL 语句、映射查询结果以及释放资源。代码通常如下：

import java.sql.*;

public class UserDao {

    public User getUserById(int userId) {
        // JDBC 连接、查询用户信息
        String url = "jdbc:mysql://localhost:3306/mydb";
        String username = "root";
        String password = "password";
        String query = "SELECT * FROM users WHERE id = ?";

        try (Connection conn = DriverManager.getConnection(url, username, password);
             PreparedStatement pstmt = conn.prepareStatement(query)) {

            pstmt.setInt(1, userId);
            ResultSet rs = pstmt.executeQuery();

            if (rs.next()) {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                return user;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}

在 JDBC 中，开发者需要显式地管理数据库连接、执行 SQL 语句、处理 ResultSet 和手动释放资源（如连接、语句和结果集）。这使得代码变得冗长且容易出错。

2. MyBatis 编程模型

与 JDBC 相比，MyBatis 通过映射机制简化了数据库操作，开发者不需要手动处理 SQL 语句的执行和结果集的映射，代码更加简洁。示例如下：

import org.apache.ibatis.annotations.Select;

public interface UserMapper {

    @Select("SELECT * FROM users WHERE id = #{userId}")
    User getUserById(int userId);
}

在 MyBatis 中，通过简单的注解或 XML 配置，SQL 语句与 Java 方法进行绑定，MyBatis 会自动执行 SQL、映射结果集并返回 Java 对象。开发者不需要关心连接的创建和关闭，也不需要处理 SQL 执行的细节。

JDBC 与 MyBatis 对比总结

特性	JDBC	MyBatis
SQL 书写方式	手动书写 SQL 语句	SQL 语句可以通过注解或 XML 配置书写
数据库连接管理	需要手动创建和关闭数据库连接	自动管理数据库连接
结果映射	手动处理 ResultSet 到 Java 对象的映射	自动映射 ResultSet 到 Java 对象
资源释放	需要手动关闭 Connection、Statement、ResultSet	自动关闭连接和资源，避免了资源泄漏
灵活性	灵活，但代码冗长且容易出错	灵活，但封装了很多细节，减少了出错的机会
代码简洁性	较冗长，需要多行代码来处理 SQL 和结果映射	简洁，通过注解或 XML 配置实现 SQL 与 Java 方法的绑定

层次结构图（Controller、Service、DAO）及资源释放流程

在 Spring Boot 项目中，常见的分层结构包括 Controller 层、Service 层和 DAO 层。下面是各层之间的关系以及资源释放的流程。

层次结构图（Controller、Service、DAO）

+--------------------+
|   Controller       |   ---> 接受 HTTP 请求，调用 Service 层方法
+--------------------+
         |
         v
+--------------------+
|   Service          |   ---> 业务逻辑层，调用 DAO 层进行数据操作
+--------------------+
         |
         v
+--------------------+
|   DAO (Data Access)|   ---> 直接与数据库进行交互，执行 SQL 查询
+--------------------+

资源释放流程图

在 JDBC 编程模型中，资源释放（如数据库连接）是开发者需要手动管理的。与之不同，MyBatis 会自动处理资源的关闭。

1. JDBC 资源释放流程：

+---------------------------+
|  开始数据库操作           |
+---------------------------+
         |
         v
+---------------------------+
|  1. 获取数据库连接         |  ---> 连接可能失败，异常处理
+---------------------------+
         |
         v
+---------------------------+
|  2. 执行 SQL 语句          |
+---------------------------+
         |
         v
+---------------------------+
|  3. 处理 ResultSet        |  ---> 映射为 Java 对象
+---------------------------+
         |
         v
+---------------------------+
|  4. 关闭 ResultSet        |  ---> 释放 ResultSet 资源
+---------------------------+
         |
         v
+---------------------------+
|  5. 关闭 PreparedStatement|
+---------------------------+
         |
         v
+---------------------------+
|  6. 关闭数据库连接        |
+---------------------------+

1. MyBatis 资源释放流程：

+---------------------------+
|  开始数据库操作           |
+---------------------------+
         |
         v
+---------------------------+
|  MyBatis 自动管理连接      |  ---> 自动管理连接池，连接被自动获取
+---------------------------+
         |
         v
+---------------------------+
|  执行 SQL 语句            |  ---> SQL 由 MyBatis 执行
+---------------------------+
         |
         v
+---------------------------+
|  MyBatis 自动映射结果      |  ---> 将 SQL 查询结果映射为 Java 对象
+---------------------------+
         |
         v
+---------------------------+
|  MyBatis 自动关闭资源      |  ---> 自动关闭 `Connection` 和 `Statement`
+---------------------------+

总结

• JDBC 需要开发者手动管理数据库连接、执行 SQL 语句以及释放资源，这导致代码较为冗长且容易出错。

• MyBatis 提供了 SQL 映射机制，使得 SQL 语句与 Java 方法绑定，自动管理数据库连接和资源，减少了重复的代码和资源管理工作，极大地提高了开发效率。

在 Spring Boot 项目中，通常采用 Controller 层、Service 层和 DAO 层的分层架构，帮助开发者组织和管理不同的业务逻辑及数据库操作。

---

结语

在软件开发的历程中，持久层的演进不仅代表了技术的进步，也反映了开发者对高效、灵活和可维护代码的追求。从 JDBC 到 MyBatis 的过渡，无疑是持久层开发中的一个重要转折点。

通过这篇文章，我们回顾了 JDBC 和 MyBatis 各自的特点与优劣，并深入探讨了 MyBatis 在简化数据库操作、提升开发效率和增强代码可维护性方面的巨大优势。

尽管 JDBC 仍然在一些特殊场景下有其存在的价值，但在现代的开发环境中，MyBatis 提供了更为灵活、可扩展且易于维护的解决方案。它不仅让数据库操作变得更简单，还能够与现代开发架构无缝融合，为开发者提供更多的自由度和控制力。⚙️

随着技术的不断发展，持久层开发也在持续变化，新的框架和工具不断涌现，但 MyBatis 作为一个成熟且强大的框架，在很多场景中仍然发挥着重要作用。

希望通过本篇文章的介绍，你对 MyBatis 和持久层开发有了更深的理解，并能将其应用于你的项目中，提高开发效率，减少重复代码。

在未来的项目中，使用 MyBatis 将让你更专注于业务逻辑和创新，而无需为数据库交互的细节所困扰。

感谢你跟随我们一起探索这个技术领域的转折点，愿你的编程之路更加顺畅！