Java JDBC教程：连接数据库与执行SQL查询

连接数据库

1. 加载 JDBC 驱动

在使用 JDBC 连接数据库之前，你需要先加载相应的 JDBC 驱动。这通常通过调用 Class.forName()方法来完成，该方法会加载指定的 JDBC 驱动类。加载驱动程序的目的是为了让 JVM 知道如何处理特定数据库的连接请求。

2. 获取数据库连接

一旦 JDBC 驱动被加载，你就可以使用 DriverManager.getConnection()方法来获取数据库连接。这通常需要提供数据库的连接 URL、用户名和密码。

3. 示例代码展示如何使用 DriverManager建立连接

下面是一个简单的示例代码，展示了如何使用 JDBC 连接到 MySQL 数据库：

import java.sql.Connection; // 导入Connection接口
import java.sql.DriverManager; // 导入用于数据库连接的DriverManager类
import java.sql.Statement; // 导入Statement接口

public class Main {
    public static void main(String[] args) throws Exception {
        // 加载MySQL JDBC驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        // 定义数据库连接信息
        String url = "jdbc:mysql://localhost:3306/my_db"; // 数据库URL
        String user = ""; // 数据库用户名
        String password = ""; // 数据库密码

        // 获取数据库连接
        Connection connection = DriverManager.getConnection(url, user, password);
    }
}

注意事项

1. 驱动程序加载：确保你已经下载了相应的 JDBC 驱动程序，并将其添加到项目的类路径中。例如，对于 MySQL 数据库，你需要将 `mysql-connector-java-x.x.x.jar` 文件添加到项目中。

2. 连接 URL：确保你提供的连接 URL 是正确的，包括主机名、端口号、数据库名等信息。例如，上面的示例中，my_db 应该替换为你实际的数据库名称。

3. 异常处理：务必处理可能出现的ClassNotFoundException和SQLException，以确保程序的健壮性。

通过上述步骤和示例代码，你可以建立起一个基本的 JDBC 连接到数据库的过程。这只是一个起点，实际应用中可能还需要进行更复杂的数据库操作和错误处理。

执行 SQL 查询

在 JDBC 中执行 SQL 查询通常涉及以下几个步骤：使用 Statement或PreparedStatement对象来发送 SQL 命令到数据库，并处理返回的ResultSet。下面分别介绍这两种方式，并提供示例代码。

 1. 使用 Statement对象执行查询

Statement对象用于执行不带参数的 SQL 命令。这是一个简单但不太安全的方法，因为它不适合用于带有用户输入的动态 SQL 语句，因为那样容易导致 SQL 注入攻击。

示例代码：

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

public class ExecuteQuery {
    public static void main(String[] args) {
        // JDBC 驱动名称与数据库 URL
        String driverName = "com.mysql.cj.jdbc.Driver";
        String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
        String user = "root";
        String pass = "";

        try {
            // 加载 JDBC 驱动
            Class.forName(driverName);

            // 获取连接
            Connection conn = DriverManager.getConnection(serverURL, user, pass);

            // 创建 Statement 对象
            Statement stmt = conn.createStatement();

            // 执行 SQL 查询
            String sql = "SELECT * FROM your_table";
            ResultSet rs = stmt.executeQuery(sql);

            // 处理 ResultSet
            while (rs.next()) {
                // 读取结果集中的数据
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");

                System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
            }

            // 关闭资源
            rs.close();
            stmt.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

2. 使用PreparedStatement对象执行参数化查询

PreparedStatement对象提供了预编译 SQL 语句的能力，使得每次执行时只需要设置不同的参数值即可。这种方法不仅可以提高性能，还可以增强安全性，因为它可以有效地防止 SQL 注入攻击。示例代码：

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

public class ExecutePreparedQuery {
    public static void main(String[] args) {
        // JDBC 驱动名称与数据库 URL
        String driverName = "com.mysql.cj.jdbc.Driver";
        String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
        String user = "root";
        String pass = "";

        try {
            // 加载 JDBC 驱动
            Class.forName(driverName);

            // 获取连接
            Connection conn = DriverManager.getConnection(serverURL, user, pass);

            // 创建 PreparedStatement 对象
            String sql = "SELECT * FROM your_table WHERE id = ?";
            PreparedStatement pstmt = conn.prepareStatement(sql);

            // 设置参数
            pstmt.setInt(1, 1); // 假设要查询 ID 为 1 的记录

            // 执行 SQL 查询
            ResultSet rs = pstmt.executeQuery();

            // 处理 ResultSet
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");

                System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);
            }

            // 关闭资源
            rs.close();
            pstmt.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

处理ResultSet

无论使用Statement还是PreparedStatement来执行查询，处理ResultSet的方式都类似。你需要通过ResultSet的方法来遍历结果集，并提取需要的数据。在上述示例代码中，我们展示了如何使用ResultSet的next()方法来遍历每一行数据，并使用getInt()和getString()等方法来获取列值。

注意事项

1. 资源管理：确保在完成操作后关闭所有打开的资源（如 ResultSet、Statement和Connection），以避免资源泄漏。
2. 异常处理：妥善处理可能出现的异常，如ClassNotFoundException和SQLException，确保程序的健壮性。
3. 安全性：使用PreparedStatement而不是Statement来处理带有用户输入的 SQL 语句，以防止 SQL 注入攻击。

事务处理

在 JDBC 中，事务处理是指对数据库的一系列操作作为一个整体来执行。如果事务中的所有操作都成功完成，则整个事务被提交；如果其中任何一个操作失败，则整个事务会被回滚，以保持数据的一致性和完整性。

如何在 JDBC 中管理事务。

在 JDBC 中，你可以通过以下步骤来管理事务：

1. 禁用自动提交：默认情况下，每当执行一个更新语句（如INSERT, UPDATE, DELETE）时，JDBC 会立即提交事务。为了手动控制事务，需要先将Connection的autoCommit属性设置为false。
2. 执行 SQL 语句：执行你的 SQL 更新语句。
3. 提交或回滚事务：根据需要，提交事务（使用Connection.commit()）或将事务回滚（使用 Connection.rollback()）。
4. 恢复自动提交模式：最后，可以将autoCommit属性重新设置为true，以便于后续的操作能够自动提交。

示例代码下面是一个示例代码，展示了如何在 JDBC 中管理事务：

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

public class TransactionExample {
    public static void main(String[] args) {
        // JDBC 驱动名称与数据库 URL
        String driverName = "com.mysql.cj.jdbc.Driver";
        String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
        String user = "root";
        String pass = "";

        try {
            // 加载 JDBC 驱动
            Class.forName(driverName);

            // 获取连接
            Connection conn = DriverManager.getConnection(serverURL, user, pass);

            // 禁用自动提交
            conn.setAutoCommit(false);

            // 创建 PreparedStatement 对象
            String sql1 = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
            PreparedStatement pstmt1 = conn.prepareStatement(sql1);
            pstmt1.setString(1, "value1");
            pstmt1.setString(2, "value2");

            // 执行第一条 SQL 插入语句
            pstmt1.executeUpdate();

            // 创建另一个 PreparedStatement 对象
            String sql2 = "UPDATE your_table SET column2 = ? WHERE column1 = ?";
            PreparedStatement pstmt2 = conn.prepareStatement(sql2);
            pstmt2.setString(1, "updated_value");
            pstmt2.setString(2, "value1");

            // 执行第二条 SQL 更新语句
            pstmt2.executeUpdate();

            // 提交事务
            conn.commit();

            // 关闭资源
            pstmt1.close();
            pstmt2.close();
            conn.close();

            System.out.println("Transaction completed successfully.");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            // 如果事务中的任何部分失败，则回滚整个事务
            try {
                if (conn != null) {
                    conn.rollback(); // 回滚事务
                    conn.close();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

示例代码说明

1. 禁用自动提交：通过调用conn.setAutoCommit(false)来禁止自动提交。
2. 执行 SQL 语句：在这个例子中，我们创建了两个PreparedStatement对象，分别用于插入和更新数据。
3. 提交事务：如果一切顺利，通过调用conn.commit()来提交事务。
4. 回滚事务：如果在执行过程中出现了任何异常，可以通过捕获异常并在catch块中调用conn.rollback()来回滚整个事务。
5. 恢复自动提交模式：在事务处理完成后，最好将autoCommit属性重新设置为true，以便于后续的操作能够自动提交。

异常处理

常见的 JDBC 异常

在使用 JDBC 进行数据库操作时，可能会遇到多种异常。了解这些异常的类型和如何处理它们对于编写健壮的应用程序至关重要。以下是一些常见的 JDBC 异常：

1.SQLException：
这是 JDBC 中最常见的一种异常，几乎所有的数据库访问错误都会抛出这个异常。SQLException 是所有其他特定异常的父类，比如SQLTimeoutException、SQLWarning等。
SQLException可以携带一个 SQL 状态码和一个错误消息，可以帮助开发者诊断问题。

2. SQLNonTransientException：
表示非瞬态的条件，即在重试后不会消失的条件。例如，当尝试访问不存在的对象时，可能会抛出此异常。

3. SQLSyntaxErrorException：
当 SQL 语法有误时抛出，例如拼写错误或语法结构错误。

4. SQLDataException：
当数据与预期不符时抛出，例如试图将一个整数放入需要字符串的字段中。

5. SQLIntegrityConstraintViolationException：
当违反了数据库完整性约束时抛出，例如尝试插入重复的主键值。

6. SQLFeatureNotSupportedException：
当请求的功能不受支持时抛出，例如使用了不支持的 JDBC 特性或方法。

7. SQLRecoverableException：
表示数据库或连接可以恢复的条件。例如，连接丢失但可以重新建立连接的情况。

8. SQLTransactionRollbackException：
当事务被强制回滚时抛出，例如因为违反了事务隔离级别。

如何捕获和处理这些异常

处理 JDBC 异常的最佳实践是使用适当的异常处理机制，确保应用程序能够优雅地处理错误并给出适当的反馈。以下是如何捕获和处理这些异常的示例：

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

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        // JDBC 驱动名称与数据库 URL
        String driverName = "com.mysql.cj.jdbc.Driver";
        String serverURL = "jdbc:mysql://localhost:3306/yourdatabase";
        String user = "root";
        String pass = "";

        Connection conn = null;
        PreparedStatement pstmt = null;

        try {
            // 加载 JDBC 驱动
            Class.forName(driverName);

            // 获取连接
            conn = DriverManager.getConnection(serverURL, user, pass);

            // 禁用自动提交
            conn.setAutoCommit(false);

            // 创建 PreparedStatement 对象
            String sql = "INSERT INTO your_table (column1, column2) VALUES (?, ?)";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "value1");
            pstmt.setString(2, "value2");

            // 执行 SQL 插入语句
            pstmt.executeUpdate();

            // 提交事务
            conn.commit();

            System.out.println("Transaction completed successfully.");
        } catch (ClassNotFoundException e) {
            // 处理找不到驱动的异常
            e.printStackTrace();
        } catch (SQLException e) {
            // 处理 SQL 相关异常
            System.err.println("SQL Exception occurred: " + e.getMessage());
            // 如果事务中的任何部分失败，则回滚整个事务
            if (conn != null) {
                try {
                    conn.rollback(); // 回滚事务
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            e.printStackTrace();
        } finally {
            // 确保所有资源都被关闭
            try {
                if (pstmt != null) pstmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

 异常处理要点

1. 捕获异常：使用try-catch块来捕获可能抛出的异常。
2. 处理异常：在catch块中处理异常，可以打印错误信息、记录日志或者根据具体情况采取相应的措施。
3. 回滚事务：如果事务中有任何部分失败，应该回滚整个事务以确保数据一致性。
4. 关闭资源：在finally块中关闭所有打开的资源，如PreparedStatement和Connection。这一步非常重要，可以防止资源泄露。
5. 异常层次结构：了解异常层次结构，捕获更具体的异常类型（如SQLException而不是 Exception），以便更好地定位问题。