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

news2025/4/14 21:25:50

前言 🌟

在软件开发的过程中，持久层（或数据访问层）是与数据库进行交互的关键部分。早期，开发者通常使用 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）：

<mapper namespace="com.example.UserMapper">
    <select id="getUserById" resultType="User">
        SELECT * FROM users WHERE id = #{userId}
    </select>
</mapper>

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

3. 动态 SQL 支持 🔄

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

动态 SQL 示例：

<select id="findUsers" resultType="User">
    SELECT * FROM users
    <where>
        <if test="name != null">AND name = #{name}</if>
        <if test="age != null">AND age = #{age}</if>
    </where>
</select>

通过动态 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 中添加如下依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Boot Starter for MySQL -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- MyBatis Spring Boot Starter -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <!-- MySQL JDBC Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- Spring Boot Starter Logging (Optional, for logging configuration) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>
</dependencies>
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 映射文件：

<mapper namespace="com.example.demo.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="email" property="email"/>
        <result column="created_at" property="createdAt"/>
    </resultMap>

    <select id="selectUserById" resultMap="BaseResultMap">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>
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 对比总结 📝

特性JDBCMyBatis
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 将让你更专注于业务逻辑和创新，而无需为数据库交互的细节所困扰。📚

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2333907.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Adobe Photoshop 2025 Mac中文 Ps图像编辑

Adobe Photoshop 2025 Mac中文 Ps图像编辑

Adobe Photoshop 2025 Mac中文 Ps图像编辑 一、介绍 Adobe Photoshop 2025 Mac版集成了多种强大的图像编辑、处理和创作功能。①强化了Adobe Sensei AI的应用&#xff0c;通过智能抠图、自动修复、图像生成等功能&#xff0c;用户能够快速而精确地编辑图像。②3D编辑和动画功…
阅读更多...
用纯Qt实现GB28181协议/实时视频/云台控制/预置位/录像回放和下载/事件订阅/语音对讲

用纯Qt实现GB28181协议/实时视频/云台控制/预置位/录像回放和下载/事件订阅/语音对讲

一、前言 在技术的长河中探索&#xff0c;有些目标一旦确立&#xff0c;便如同璀璨星辰&#xff0c;指引着我们不断前行。早在2014年&#xff0c;我心中就种下了用纯Qt实现GB28181协议的种子&#xff0c;如今回首&#xff0c;一晃十年已逝&#xff0c;好在整体框架和逻辑终于打…
阅读更多...
让你方便快捷实现主题色切换（useCssVar）

让你方便快捷实现主题色切换（useCssVar）

文章目录 前言一、useCssVar是什么&#xff1f;二、使用步骤1.安装依赖2.实现主题色切换 总结 前言 使用 CSS 变量&#xff08;CSS Custom Properties&#xff09;实现主题色切换是一种高效且易于维护的方法。通过将主题颜色定义为 CSS 变量&#xff0c;你可以轻松地在不同主题…
阅读更多...
面试之《websocket》

面试之《websocket》

配置环境 mkdir express cd express npm init npm install express ws// index.js var app require("express")(); var WebSocket require("ws");var wss new WebSocket.Server({ port: 8888 });wss.on(connection, function connection(ws) {ws.on(m…
阅读更多...
L36.【LeetCode题解】查找总价格为目标值的两个商品(剑指offer:和为s的两个数字) (双指针思想,内含详细的优化过程)

L36.【LeetCode题解】查找总价格为目标值的两个商品(剑指offer:和为s的两个数字) (双指针思想,内含详细的优化过程)

目录 1.LeetCode题目 2.分析 方法1:暴力枚举(未优化的双指针) 方法2:双指针优化:利用有序数组的单调性 版本1代码 提问:版本1代码有可以优化的空间吗? 版本2代码 提问:版本2代码有可以优化的空间吗? 版本3代码(★推荐★) 3.牛客网题目:和为s的数字 1.LeetCode题目 …
阅读更多...
英语学习4.9

英语学习4.9

cordial 形容词&#xff1a; 热情友好的&#xff0c;诚恳的 表示一个人态度温和、亲切&#xff0c;给人温暖和善的感觉。 令人愉快的&#xff0c;和睦的 形容关系融洽、氛围和谐。 例句​​&#xff1a; The two leaders had a ​​cordial​​ but formal discussion. &am…
阅读更多...
MyBatis-Plus 核心功能

MyBatis-Plus 核心功能

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 一、条件构造器1、核心 Wrapper 类型基础查询示例SQL 查询使用 QueryWrapper 实现查询 更新操作示例场景一&#xff1a;基础更新SQL 查询使用 QueryWrapper 实现更新…
阅读更多...
Day22 -php开发01--留言板+知识点（超全局变量 文件包含 数据库操作 第三方插件）

Day22 -php开发01--留言板+知识点（超全局变量 文件包含 数据库操作 第三方插件）

环境要求&#xff1a;php7.0.9 小皮 navicat phpstorm24.1 知识点&#xff1a;会写&#xff08;留言板 留言板后台&#xff09; 超全局变量 三方插件的使用 文件包含 1、开启小皮并利用navicat新建一个数据库 注意&#xff1a;本地的服务mysql关闭后 才可打开小皮。属…
阅读更多...
Java工具类-assert断言

Java工具类-assert断言

我们可能经常在项目的单元测试或者一些源码中看到别人在使用assert关键字&#xff0c;当然也不只是Java语言&#xff0c;很多编程语言也都能看到&#xff0c;我们大概知道断言可以用于测试中条件的校验&#xff0c;但却不经常使用&#xff0c;本文总结了Java中该工具类的使用。…
阅读更多...
人工智能、机器学习与深度学习-AI基础Day2

人工智能、机器学习与深度学习-AI基础Day2

核心概念与技术全景解析 近年来&#xff0c;人工智能&#xff08;AI&#xff09;技术飞速发展&#xff0c;逐渐渗透到生活的方方面面。然而&#xff0c;对于许多人来说&#xff0c;AI、机器学习&#xff08;ML&#xff09;、深度学习&#xff08;DL&#xff09;以及生成式人工…
阅读更多...
GGML源码逐行调试（上）

GGML源码逐行调试（上）

目录 前言1. 简述2. 环境配置3. ggml核心概念3.1 gguf3.2 ggml_tensor3.3 ggml_backend_buffer3.4 ggml_context3.5 backend3.6 ggml_cgraph3.7 ggml_gallocr 4. 推理流程整体梳理4.1 时间初始化与参数设置4.2 模型加载与词汇表构建4.3 计算图与内存分配4.4 文本预处理与推理过…
阅读更多...
SpringCloud-OpenFeign

SpringCloud-OpenFeign

前言 1.存在问题 远程调用可以像Autowired一样吗 服务之间的通信⽅式,通常有两种:RPC和HTTP. 在SpringCloud中,默认是使⽤HTTP来进⾏微服务的通信,最常⽤的实现形式有两种&#xff1a; RestTemplate OpenFeign RPC&#xff08;RemoteProcedureCall&#xff09;远程过程调⽤&…
阅读更多...
撰写学位论文Word图表目录的自动生成

撰写学位论文Word图表目录的自动生成

第一步&#xff1a;为图片和表格添加题注 选中图片或表格 右键点击需要编号的图片或表格&#xff0c;选择 【插入题注】&#xff08;或通过菜单栏 引用 → 插入题注&#xff09;。 设置题注标签 在弹窗中选择 标签&#xff08;如默认有“图”“表”&#xff0c;若无需自定义标…
阅读更多...
Web 项目实战：构建属于自己的博客系统

Web 项目实战：构建属于自己的博客系统

目录 项目效果演示 代码 Gitee 地址 1. 准备工作 1.1 建表 1.2 引入 MyBatis-plus 依赖 1.3 配置数据库连接 1.4 项目架构 2. 实体类准备 - pojo 包 2.1 dataobject 包 2.2 request 包 2.3 response 包 2.3.1 统一响应结果类 - Result 2.3.2 用户登录响应类 2.3.3…
阅读更多...
【随行付-注册安全分析报告-无验证方式导致隐患】

【随行付-注册安全分析报告-无验证方式导致隐患】

前言 由于网站注册入口容易被黑客攻击&#xff0c;存在如下安全问题&#xff1a; 1. 暴力破解密码&#xff0c;造成用户信息泄露 2. 短信盗刷的安全问题&#xff0c;影响业务及导致用户投诉 3. 带来经济损失&#xff0c;尤其是后付费客户&#xff0c;风险巨大&#xff0c;造…
阅读更多...
什么是原型、原型链？

什么是原型、原型链？

一、原型 每个函数都有一个prototype属性&#xff0c;称之为原型&#xff0c;也称为原型对象。 原型可以放一些属性和方法&#xff0c;共享给实例对象使用。原型可以用作继承 二、原型链 对象都有_proto_属性&#xff0c;这个属性指向它的原型对象&#xff0c;原型对象也是…
阅读更多...
ChatGPT的GPT-4o创建图像Q版人物提示词实例展示

ChatGPT的GPT-4o创建图像Q版人物提示词实例展示

最近感觉GPT-4o发布的新功能真的强大&#xff0c;所以总结了一些提示词分享给大家&#xff0c;大家可以去试试&#xff0c;玩法多多&#xff0c;可以用GPT-4o生成图片&#xff0c;然后用可灵进行图生视频&#xff0c;就能去发布视频了&#xff01;接下来和笔者一起来试试&#…
阅读更多...
StringBuffer类基本使用

StringBuffer类基本使用

文章目录 1. 基本介绍2. String VS StringBuffer3. String和StringBuffer相互转换4. StringBuffer类常见方法5. StringBuffer类测试 1. 基本介绍 java.lang.StringBuffer 代表可变的字符序列&#xff0c;可以对字符串内容进行增删很多方法与String相同&#xff0c;但StringBuf…
阅读更多...
基于 Maven 构建的 Thingsboard 3.8.1 项目结构

基于 Maven 构建的 Thingsboard 3.8.1 项目结构

一、生命周期&#xff08;Lifecycle&#xff09; Maven 的生命周期定义了项目构建和部署的各个阶段&#xff0c;图中列出了标准的生命周期阶段&#xff1a; clean&#xff1a;清理项目&#xff0c;删除之前构建生成的临时文件和输出文件。validate&#xff1a;验证项目配置是否…
阅读更多...
为啥物联网用MQTT？

为啥物联网用MQTT？

前言 都说物联网用MQTT&#xff0c;那分别使用Http和Mqtt发送“Hello”&#xff0c;比较一下就知道啦 HTTP HTTP请求报文由请求行、头部字段和消息体组成。一个最简单的HTTP POST请求如下&#xff1a; POST / HTTP/1.1 Host: example.com Content-Length: 5 Content-Type: …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023