深入 Java JDBC 数据库操作：通过 JDBC API 连接关系型数据库，执行 SQL 查询与更新，实现数据持久化。

各位 Java 程序员，早上好、中午好、晚上好！ 🌞🌙

我是你们的老朋友，代码界的段子手，Bug 界的清道夫。今天，咱们不聊高并发，不谈微服务，回归本源，聊聊 Java 开发里最基础、但也最重要的一个环节：JDBC 数据库操作。

想象一下，你的程序就像一个辛勤的园丁，精心培育着各种数据。而数据库呢？就像一片沃土，为这些数据提供持久的家园。JDBC，就是园丁和沃土之间的桥梁，连接两者，让数据的生命得以延续。

准备好了吗？让我们开始这场数据持久化的奇妙之旅吧！🚀

第一站：JDBC 是什么？为什么我们需要它？

首先，来个灵魂拷问：如果没有 JDBC，我们的 Java 程序该如何与数据库对话呢？难道要像原始人一样，用石头敲击键盘，发出咿咿呀呀的指令吗？ 🙅‍♂️

当然不是！JDBC（Java Database Connectivity）就是 Java 连接数据库的规范。它是一组接口和类，定义了 Java 程序访问数据库的标准方式。你可以把它想象成一个翻译器，将 Java 代码翻译成数据库能够理解的 SQL 指令，再将数据库返回的结果翻译回 Java 对象。

为什么我们需要 JDBC？

• 统一标准： 不同数据库（如 MySQL、Oracle、PostgreSQL）有不同的驱动程序，JDBC 提供了一套统一的 API，让我们可以用相同的代码访问不同的数据库，而无需关心底层细节。这就像使用统一的插座标准，无论你用的是什么电器，都能轻松插入使用。🔌
• 简化操作： JDBC 封装了复杂的数据库操作细节，提供了简洁易用的 API，让我们可以方便地执行 SQL 查询、更新、删除等操作。
• 提高效率： JDBC 驱动程序经过优化，能够高效地连接数据库，传输数据，提高程序的运行效率。

第二站：JDBC 的架构：三层结构，清晰明了

JDBC 的架构非常清晰，就像一座三层楼房，每一层都有自己的职责：

• 第一层：JDBC API

  这是我们直接使用的接口和类，定义了连接数据库、执行 SQL 语句、处理结果集等操作。例如，DriverManager、Connection、Statement、ResultSet 等。你可以把它们看作是建筑的蓝图，规定了如何建造房屋。

• 第二层：JDBC Driver Manager

  DriverManager 负责加载数据库驱动程序，并根据连接 URL 选择合适的驱动程序。它就像建筑的监理，负责监督施工过程，确保按照蓝图进行。

• 第三层：JDBC Driver

  这是数据库厂商提供的驱动程序，负责与具体的数据库进行通信。它实现了 JDBC API 接口，将 Java 代码翻译成数据库能够理解的指令。就像建筑工人，负责具体施工，将蓝图变成现实。

可以用下面的表格来总结：

层次	组件	职责	比喻
第一层	JDBC API	定义了连接数据库、执行 SQL 语句、处理结果集等操作的标准接口。	建筑蓝图
第二层	JDBC Driver Manager	负责加载数据库驱动程序，并根据连接 URL 选择合适的驱动程序。	建筑监理
第三层	JDBC Driver	由数据库厂商提供，负责与具体的数据库进行通信，将 Java 代码翻译成数据库能够理解的指令。	建筑工人

第三站：JDBC 核心 API：掌握它们，游刃有余

想要玩转 JDBC，必须掌握以下几个核心 API：

1. DriverManager： 驱动管理器，负责加载和管理数据库驱动程序。

   • DriverManager.getConnection(url, user, password)：建立数据库连接。

2. Connection： 代表一个数据库连接，通过它可以创建 Statement 对象。

   • connection.createStatement()：创建 Statement 对象，用于执行静态 SQL 语句。
   • connection.prepareStatement(sql)：创建 PreparedStatement 对象，用于执行预编译 SQL 语句，防止 SQL 注入。
   • connection.setAutoCommit(boolean)：设置是否自动提交事务。
   • connection.commit()：提交事务。
   • connection.rollback()：回滚事务。
   • connection.close()：关闭连接，释放资源。

3. Statement： 用于执行静态 SQL 语句。

   • statement.executeQuery(sql)：执行 SELECT 语句，返回 ResultSet 对象。
   • statement.executeUpdate(sql)：执行 INSERT、UPDATE、DELETE 语句，返回受影响的行数。
   • statement.execute(sql)：执行任意 SQL 语句，返回 boolean 值，表示是否有结果集。
   • statement.close()：关闭语句，释放资源。

4. PreparedStatement： 用于执行预编译 SQL 语句，可以防止 SQL 注入，提高执行效率。

   • preparedStatement.setString(index, value)：设置字符串类型的参数。
   • preparedStatement.setInt(index, value)：设置整数类型的参数。
   • preparedStatement.setDate(index, value)：设置日期类型的参数。
   • preparedStatement.executeQuery()：执行 SELECT 语句，返回 ResultSet 对象。
   • preparedStatement.executeUpdate()：执行 INSERT、UPDATE、DELETE 语句，返回受影响的行数。
   • preparedStatement.close()：关闭语句，释放资源。

5. ResultSet： 代表 SQL 查询的结果集，可以从中读取数据。

   • resultSet.next()：移动到下一行，如果存在下一行则返回 true，否则返回 false。
   • resultSet.getString(columnName)：获取指定列名的字符串值。
   • resultSet.getInt(columnName)：获取指定列名的整数值。
   • resultSet.getDate(columnName)：获取指定列名的日期值。
   • resultSet.close()：关闭结果集，释放资源。

掌握了这些核心 API，你就拥有了与数据库对话的钥匙，可以自由地查询、更新、删除数据。🔑

第四站：JDBC 实战：代码示例，手把手教学

光说不练假把式！下面，我们通过几个代码示例，来演示如何使用 JDBC 进行数据库操作。

1. 连接数据库：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBUtil {

    private static final String URL = "jdbc:mysql://localhost:3306/mydatabase?serverTimezone=UTC";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver"); // 加载驱动
        } catch (ClassNotFoundException e) {
            System.err.println("找不到 MySQL JDBC 驱动！");
            e.printStackTrace();
            return null;
        }
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }

    public static void main(String[] args) {
        try (Connection connection = getConnection()) {
            if (connection != null) {
                System.out.println("数据库连接成功！🎉");
            } else {
                System.out.println("数据库连接失败！😢");
            }
        } catch (SQLException e) {
            System.err.println("数据库连接出错！");
            e.printStackTrace();
        }
    }
}

代码解读：

• 首先，我们需要加载数据库驱动程序。不同的数据库需要加载不同的驱动程序。
• 然后，使用 DriverManager.getConnection() 方法建立数据库连接。需要提供连接 URL、用户名和密码。
• 连接 URL 的格式为：jdbc:<database>://<host>:<port>/<databaseName>。
• 连接成功后，可以使用 Connection 对象进行后续操作。
• try-with-resources 语句可以确保在程序执行完毕后，自动关闭连接，释放资源。这是一个良好的编程习惯。 👍

2. 查询数据：

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class QueryData {

    public static void main(String[] args) {
        try (Connection connection = DBUtil.getConnection();
             Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery("SELECT id, name, age FROM users")) {

            System.out.println("查询结果：");
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");
                System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
            }

        } catch (SQLException e) {
            System.err.println("查询数据出错！");
            e.printStackTrace();
        }
    }
}

代码解读：

• 首先，通过 connection.createStatement() 方法创建一个 Statement 对象。
• 然后，使用 statement.executeQuery() 方法执行 SELECT 语句，返回 ResultSet 对象。
• ResultSet 对象包含了查询结果集，可以使用 resultSet.next() 方法遍历结果集。
• 使用 resultSet.getString()、resultSet.getInt() 等方法获取指定列的值。

3. 更新数据：

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class UpdateData {

    public static void main(String[] args) {
        try (Connection connection = DBUtil.getConnection();
             Statement statement = connection.createStatement()) {

            String sql = "UPDATE users SET age = 30 WHERE name = 'Alice'";
            int rowsAffected = statement.executeUpdate(sql);

            System.out.println("受影响的行数：" + rowsAffected);

        } catch (SQLException e) {
            System.err.println("更新数据出错！");
            e.printStackTrace();
        }
    }
}

代码解读：

• 使用 statement.executeUpdate() 方法执行 UPDATE 语句，返回受影响的行数。

4. 插入数据 (使用 PreparedStatement 防止 SQL 注入)：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class InsertData {

    public static void main(String[] args) {
        try (Connection connection = DBUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO users (name, age) VALUES (?, ?)")) {

            preparedStatement.setString(1, "Bob");
            preparedStatement.setInt(2, 25);

            int rowsAffected = preparedStatement.executeUpdate();

            System.out.println("受影响的行数：" + rowsAffected);

        } catch (SQLException e) {
            System.err.println("插入数据出错！");
            e.printStackTrace();
        }
    }
}

代码解读：

• 使用 connection.prepareStatement() 方法创建 PreparedStatement 对象，传入带有占位符 ? 的 SQL 语句。
• 使用 preparedStatement.setString()、preparedStatement.setInt() 等方法设置参数值。
• 使用 preparedStatement.executeUpdate() 方法执行 INSERT 语句，返回受影响的行数。
• 注意： 使用 PreparedStatement 可以有效防止 SQL 注入攻击，提高程序的安全性。 🛡️

5. 事务处理：

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

public class TransactionExample {

    public static void main(String[] args) {
        Connection connection = null;
        try {
            connection = DBUtil.getConnection();
            connection.setAutoCommit(false); // 关闭自动提交

            Statement statement = connection.createStatement();
            statement.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
            statement.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2");

            connection.commit(); // 提交事务
            System.out.println("转账成功！💰");

        } catch (SQLException e) {
            System.err.println("转账失败！");
            try {
                if (connection != null) {
                    connection.rollback(); // 回滚事务
                    System.out.println("事务已回滚！↩️");
                }
            } catch (SQLException ex) {
                System.err.println("回滚事务失败！");
                ex.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            try {
                if (connection != null) {
                    connection.close(); // 关闭连接
                }
            } catch (SQLException e) {
                System.err.println("关闭连接失败！");
                e.printStackTrace();
            }
        }
    }
}

代码解读：

• 首先，关闭自动提交 connection.setAutoCommit(false)。
• 然后，执行一系列 SQL 语句。
• 如果所有语句都执行成功，则提交事务 connection.commit()。
• 如果任何一个语句执行失败，则回滚事务 connection.rollback()，撤销所有操作，保证数据的一致性。
• 注意： 事务处理是保证数据一致性的重要手段。

第五站：JDBC 最佳实践：避免踩坑，提升效率

在使用 JDBC 进行数据库操作时，有一些最佳实践可以帮助你避免踩坑，提升效率：

1. 使用连接池： 连接数据库是一个昂贵的操作，频繁地创建和关闭连接会影响程序的性能。使用连接池可以复用数据库连接，提高程序的效率。常见的连接池有 C3P0、DBCP、HikariCP 等。
2. 使用 PreparedStatement： PreparedStatement 可以防止 SQL 注入攻击，提高程序的安全性，同时也可以提高执行效率。
3. 及时关闭连接、语句和结果集： 数据库连接、语句和结果集都是宝贵的资源，使用完毕后应该及时关闭，释放资源。可以使用 try-with-resources 语句自动关闭资源。
4. 处理异常： 数据库操作可能会抛出 SQLException 异常，应该及时捕获并处理异常，避免程序崩溃。
5. 使用事务： 事务可以保证数据的一致性，应该在需要保证数据一致性的场景下使用事务。
6. 避免在循环中执行 SQL 语句： 在循环中执行 SQL 语句会严重影响程序的性能。应该尽量将 SQL 语句批量执行。
7. 使用分页查询： 如果查询结果集很大，应该使用分页查询，避免一次性加载所有数据，导致内存溢出。
8. 索引优化： 合理使用索引可以提高查询效率。
9. 选择合适的数据库： 根据实际需求选择合适的数据库。

第六站：JDBC 的未来：拥抱 ORM 框架，告别手写 SQL

虽然 JDBC 是 Java 数据库操作的基础，但直接使用 JDBC API 编写 SQL 语句是一件繁琐的事情。为了简化数据库操作，出现了许多 ORM（Object-Relational Mapping）框架，例如 Hibernate、MyBatis、Spring Data JPA 等。

ORM 框架可以将 Java 对象映射到数据库表，让我们只需要操作 Java 对象，而无需关心 SQL 语句的编写。这就像使用高级编程语言，让我们只需要关注业务逻辑，而无需关心底层细节。

未来，随着 ORM 框架的不断发展，手写 SQL 语句的场景会越来越少。但是，理解 JDBC 的原理仍然非常重要，因为它是 ORM 框架的基础。只有理解了 JDBC 的原理，才能更好地使用 ORM 框架，解决实际问题。

总结：

今天，我们一起探索了 Java JDBC 数据库操作的奥秘，从 JDBC 的概念、架构、核心 API，到 JDBC 的实战示例和最佳实践，再到 JDBC 的未来发展趋势。希望通过今天的学习，你能够更加熟练地使用 JDBC 进行数据库操作，为你的 Java 程序构建坚实的数据基础。

记住，JDBC 是连接 Java 程序和数据库的桥梁，是数据持久化的基石。掌握 JDBC，你就能驾驭数据，掌控未来！ 🚀

感谢大家的观看，我们下期再见！ 👋