MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java使用JDBC实现数据库连接

2022-12-273.9k 阅读

Java 使用 JDBC 实现数据库连接

1. JDBC 概述

Java Database Connectivity（JDBC）是 Java 编程语言中用于执行 SQL 语句的 API，它为数据库访问提供了一种标准的方式。通过 JDBC，Java 程序可以与各种关系型数据库（如 MySQL、Oracle、SQL Server 等）进行交互，实现数据的查询、插入、更新和删除等操作。JDBC 使得 Java 开发者可以以一种统一的方式操作不同的数据库，而无需为每种数据库编写特定的代码。

JDBC 的核心类和接口位于 java.sql 包和 javax.sql 包中。java.sql 包提供了基本的数据库访问功能，而 javax.sql 包则在其基础上提供了更高级的数据库连接池、分布式事务等功能。

2. 数据库驱动的概念与类型

2.1 数据库驱动概念

数据库驱动是 JDBC 与特定数据库之间的桥梁，它负责将 JDBC 调用转换为数据库能够理解的原生调用。不同的数据库需要不同的驱动程序，例如 MySQL 有其对应的 MySQL Connector/J 驱动，Oracle 有 Oracle JDBC 驱动等。

2.2 数据库驱动类型

  • JDBC - ODBC 桥接驱动：这种驱动类型允许 Java 应用程序通过 ODBC（Open Database Connectivity）接口访问数据库。ODBC 是一种广泛使用的数据库访问标准，但是由于它依赖于本地库，在跨平台性方面存在一定的局限性，并且性能相对较低。在现代开发中，这种驱动类型已经较少使用。
  • 本地 API 部分 Java 驱动：这种类型的驱动使用 Java 编写，但部分功能依赖于数据库厂商提供的本地库。它通过调用本地库来与数据库进行交互，因此在跨平台性上也有一定限制，并且部署时需要确保本地库在目标系统上正确安装和配置。
  • 网络协议纯 Java 驱动：该驱动完全用 Java 编写，通过网络协议与数据库服务器进行通信。它将 JDBC 调用转换为特定的网络协议消息发送到数据库服务器，然后接收服务器的响应并转换为 JDBC 结果。这种驱动具有良好的跨平台性，是目前较为常用的驱动类型之一。例如 MySQL Connector/J 就属于此类驱动。
  • 本地协议纯 Java 驱动：同样完全用 Java 编写，直接将 JDBC 调用转换为数据库的本地协议。这种驱动直接与数据库服务器进行交互，无需中间层，因此性能较高，但它针对特定的数据库进行开发，与特定数据库的耦合度较高。

3. 准备工作

3.1 安装数据库

在实际应用中，我们可以选择不同的数据库系统，这里以 MySQL 为例。首先需要从 MySQL 官方网站下载并安装 MySQL 数据库。安装过程中需要设置 root 用户的密码等相关信息，安装完成后确保 MySQL 服务已经启动。

3.2 下载并添加数据库驱动

对于 MySQL 数据库，我们需要下载 MySQL Connector/J 驱动。可以从 MySQL 官方网站的下载页面获取对应的驱动文件（通常是一个 .jar 文件）。下载完成后，需要将该 .jar 文件添加到 Java 项目的类路径中。

如果使用的是 Eclipse 等 IDE，添加方法如下：

  1. 在项目上右键单击，选择“Properties”。
  2. 在弹出的对话框中选择“Java Build Path”。
  3. 切换到“Libraries”选项卡，点击“Add External JARs...”按钮。
  4. 选择下载的 MySQL Connector/J 驱动 .jar 文件，点击“Open”，然后点击“OK”。

如果是使用命令行编译和运行 Java 程序，可以通过 -cp 选项将驱动 .jar 文件添加到类路径中，例如：

java -cp.:mysql-connector-java-8.0.26.jar MainClass

这里假设下载的驱动文件名为 mysql-connector-java-8.0.26.jar，并且当前目录为项目根目录。

4. 使用 JDBC 实现数据库连接的基本步骤

4.1 加载数据库驱动

在 Java 程序中，需要首先加载数据库驱动，告诉 JVM 使用哪个驱动来连接数据库。对于 MySQL Connector/J 驱动，在 Java 8 及以上版本，可以使用 DriverManager 类的 getConnection 方法时自动加载驱动，无需显式加载。但在旧版本中，通常使用如下代码显式加载驱动：

try {
    Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

这里使用 Class.forName 方法加载 MySQL 驱动类。如果驱动类不在类路径中，会抛出 ClassNotFoundException 异常。

4.2 建立数据库连接

加载驱动后，就可以使用 DriverManager 类的 getConnection 方法来建立与数据库的连接。getConnection 方法有多个重载版本，常用的版本需要传入数据库的 URL、用户名和密码。对于 MySQL 数据库，URL 的格式通常为 jdbc:mysql://host:port/databaseName，其中 host 是数据库服务器的主机名，port 是数据库服务器监听的端口号（MySQL 默认端口号为 3306），databaseName 是要连接的数据库名称。例如：

String url = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
try (Connection connection = DriverManager.getConnection(url, username, password)) {
    // 连接成功，在这里可以进行数据库操作
} catch (SQLException e) {
    e.printStackTrace();
}

这里使用 try-with-resources 语句来管理 Connection 对象，确保在使用完毕后自动关闭连接，释放资源。DriverManager.getConnection 方法可能会抛出 SQLException 异常，如果连接失败，例如数据库服务器未启动、用户名或密码错误等，就会抛出该异常。

4.3 创建 SQL 语句执行对象

建立连接后，需要创建一个 SQL 语句执行对象，用于执行 SQL 语句。JDBC 提供了三种类型的执行对象：Statement、PreparedStatement 和 CallableStatement。

  • Statement：最基本的执行对象，用于执行静态 SQL 语句。静态 SQL 语句在编写程序时就已经确定，不会根据程序运行时的条件动态变化。例如：
Statement statement = connection.createStatement();
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);

这里使用 createStatement 方法创建 Statement 对象，然后使用 executeQuery 方法执行 SQL 查询语句，返回一个 ResultSet 对象，用于存储查询结果。

  • PreparedStatement：用于执行动态 SQL 语句。动态 SQL 语句可以根据程序运行时的条件动态变化，并且 PreparedStatement 具有预编译功能，能够提高执行效率，同时还能有效防止 SQL 注入攻击。例如：
String sql = "SELECT * FROM users WHERE username =? AND password =?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "admin");
preparedStatement.setString(2, "123456");
ResultSet resultSet = preparedStatement.executeQuery();

这里使用 prepareStatement 方法创建 PreparedStatement 对象，SQL 语句中的 ? 是占位符，通过 setString 等方法为占位符赋值。

  • CallableStatement：用于执行存储过程。存储过程是数据库中预编译好的一组 SQL 语句，具有较高的执行效率和安全性。例如，假设数据库中有一个名为 getUserById 的存储过程，接受一个 id 参数并返回用户信息：
String sql = "{call getUserById(?)}";
CallableStatement callableStatement = connection.prepareCall(sql);
callableStatement.setInt(1, 1);
ResultSet resultSet = callableStatement.executeQuery();

这里使用 prepareCall 方法创建 CallableStatement 对象，{call...} 是调用存储过程的语法格式，同样通过 setInt 等方法为参数赋值。

4.4 执行 SQL 语句

根据不同的 SQL 语句类型和执行对象，使用相应的方法执行 SQL 语句。

  • 执行查询语句：对于查询语句（SELECT 语句），使用 executeQuery 方法，返回一个 ResultSet 对象。例如：
Statement statement = connection.createStatement();
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String username = resultSet.getString("username");
    String password = resultSet.getString("password");
    System.out.println("ID: " + id + ", Username: " + username + ", Password: " + password);
}

这里通过 ResultSet 的 next 方法遍历结果集，使用 getInt、getString 等方法获取每列的数据。

  • 执行更新语句：对于更新语句（INSERT、UPDATE、DELETE 语句），使用 executeUpdate 方法，返回一个整数，表示受影响的行数。例如：
String sql = "INSERT INTO users (username, password) VALUES ('newuser', 'newpassword')";
Statement statement = connection.createStatement();
int rowsAffected = statement.executeUpdate(sql);
System.out.println("Rows affected: " + rowsAffected);

这里执行 INSERT 语句，并输出受影响的行数。

4.5 处理执行结果

对于查询语句，需要处理 ResultSet 对象来获取查询结果。ResultSet 对象提供了一系列的 get 方法，根据列的数据类型获取相应的值。例如：

ResultSet resultSet = statement.executeQuery("SELECT id, username, password FROM users");
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String username = resultSet.getString("username");
    String password = resultSet.getString("password");
    // 在这里可以对获取到的数据进行进一步处理
}

对于更新语句，通过 executeUpdate 方法返回的受影响行数来判断操作是否成功。例如：

int rowsAffected = statement.executeUpdate("UPDATE users SET password = 'newpassword' WHERE username = 'olduser'");
if (rowsAffected > 0) {
    System.out.println("Update successful");
} else {
    System.out.println("No rows updated");
}

4.6 关闭资源

在完成数据库操作后，需要关闭相关的资源，包括 ResultSet、Statement 和 Connection。使用 try-with-resources 语句可以方便地管理资源的关闭，确保资源在使用完毕后自动关闭。例如：

try (Connection connection = DriverManager.getConnection(url, username, password);
     Statement statement = connection.createStatement();
     ResultSet resultSet = statement.executeQuery("SELECT * FROM users")) {
    // 执行数据库操作并处理结果
} catch (SQLException e) {
    e.printStackTrace();
}

如果不使用 try-with-resources 语句，也可以手动调用 close 方法关闭资源，注意关闭的顺序应该是先关闭 ResultSet，再关闭 Statement，最后关闭 Connection。例如：

Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
    connection = DriverManager.getConnection(url, username, password);
    statement = connection.createStatement();
    resultSet = statement.executeQuery("SELECT * FROM users");
    // 执行数据库操作并处理结果
} catch (SQLException e) {
    e.printStackTrace();
} finally {
    try {
        if (resultSet != null) {
            resultSet.close();
        }
        if (statement != null) {
            statement.close();
        }
        if (connection != null) {
            connection.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

5. 完整代码示例

下面是一个完整的使用 JDBC 连接 MySQL 数据库并执行简单查询和插入操作的示例代码：

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

public class JDBCExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String username = "root";
        String password = "password";

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            // 查询操作
            String selectSql = "SELECT * FROM users";
            try (PreparedStatement selectStatement = connection.prepareStatement(selectSql);
                 ResultSet resultSet = selectStatement.executeQuery()) {
                System.out.println("Query results:");
                while (resultSet.next()) {
                    int id = resultSet.getInt("id");
                    String usernameCol = resultSet.getString("username");
                    String passwordCol = resultSet.getString("password");
                    System.out.println("ID: " + id + ", Username: " + usernameCol + ", Password: " + passwordCol);
                }
            }

            // 插入操作
            String insertSql = "INSERT INTO users (username, password) VALUES (?,?)";
            try (PreparedStatement insertStatement = connection.prepareStatement(insertSql)) {
                insertStatement.setString(1, "newuser");
                insertStatement.setString(2, "newpassword");
                int rowsAffected = insertStatement.executeUpdate();
                System.out.println("Rows affected by insert: " + rowsAffected);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，首先通过 DriverManager.getConnection 方法建立与 MySQL 数据库的连接。然后分别执行了查询操作和插入操作，查询操作使用 PreparedStatement 执行 SELECT 语句并遍历结果集输出数据，插入操作同样使用 PreparedStatement 执行 INSERT 语句并输出受影响的行数。整个过程使用 try-with-resources 语句来管理资源的关闭。

6. JDBC 连接池

6.1 连接池的概念

在实际的企业级应用中，频繁地创建和销毁数据库连接会带来很大的性能开销。为了解决这个问题，引入了数据库连接池的概念。数据库连接池是一个预先创建好的数据库连接的集合，应用程序需要数据库连接时，从连接池中获取一个连接，使用完毕后再将连接放回连接池，而不是每次都创建和销毁连接。

6.2 使用 HikariCP 连接池

HikariCP 是一个高性能的 JDBC 连接池，在 Java 项目中被广泛使用。下面是使用 HikariCP 连接池的示例：

首先，需要在项目的 pom.xml 文件中添加 HikariCP 的依赖（如果使用 Maven 构建项目）：

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>4.0.3</version>
</dependency>

然后，在 Java 代码中使用 HikariCP 连接池：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class HikariCPExample {
    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("password");
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
        dataSource = new HikariDataSource(config);
    }

    public static void main(String[] args) {
        try (Connection connection = dataSource.getConnection();
             PreparedStatement statement = connection.prepareStatement("SELECT * FROM users");
             ResultSet resultSet = statement.executeQuery()) {
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                String password = resultSet.getString("password");
                System.out.println("ID: " + id + ", Username: " + username + ", Password: " + password);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，首先在静态代码块中创建了 HikariConfig 对象并设置数据库连接相关的属性，然后通过 HikariConfig 创建 HikariDataSource 对象。在 main 方法中，通过 HikariDataSource 获取数据库连接并执行查询操作。

7. 常见问题与解决方法

7.1 驱动加载问题

  • 问题描述：运行程序时抛出 ClassNotFoundException 异常，提示找不到数据库驱动类。
  • 解决方法：确保数据库驱动 .jar 文件已经正确添加到项目的类路径中。如果是手动添加，检查路径是否正确；如果使用 IDE，检查项目的构建路径设置。另外，在 Java 8 及以上版本，虽然通常无需显式加载驱动，但某些特殊情况下可能仍需要显式加载，例如使用较旧的 JDBC 代码库时，需要按照前面介绍的方法显式加载驱动。

7.2 连接失败问题

  • 问题描述：调用 DriverManager.getConnection 方法时抛出 SQLException 异常，提示连接失败。
  • 解决方法：首先检查数据库服务器是否已经启动，网络是否正常。然后确认数据库 URL、用户名和密码是否正确。对于 MySQL 数据库，注意 URL 格式是否正确，端口号是否与 MySQL 服务器配置一致。如果使用了防火墙，确保数据库服务器的端口没有被阻止。

7.3 SQL 注入问题

  • 问题描述：在使用 Statement 执行动态 SQL 语句时，如果用户输入的数据未经过适当处理，可能会导致 SQL 注入攻击，例如恶意用户通过输入特殊字符来改变 SQL 语句的逻辑，从而获取敏感数据或执行非法操作。
  • 解决方法：尽量使用 PreparedStatement 代替 Statement。PreparedStatement 会对参数进行预编译，能够有效防止 SQL 注入攻击。例如，不要使用如下容易导致 SQL 注入的代码：
String username = request.getParameter("username");
String password = request.getParameter("password");
String sql = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql);

而应该使用 PreparedStatement：

String username = request.getParameter("username");
String password = request.getParameter("password");
String sql = "SELECT * FROM users WHERE username =? AND password =?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, username);
preparedStatement.setString(2, password);
ResultSet resultSet = preparedStatement.executeQuery();

7.4 资源未关闭问题

  • 问题描述：程序运行后，数据库连接等资源没有及时关闭，可能导致资源泄漏，长时间运行后系统性能下降甚至崩溃。
  • 解决方法：使用 try-with-resources 语句来管理 Connection、Statement 和 ResultSet 等资源，确保它们在使用完毕后自动关闭。如果不能使用 try-with-resources（例如在 Java 7 之前的版本），则需要在 finally 块中手动调用 close 方法关闭资源，并注意按照正确的顺序关闭，即先关闭 ResultSet，再关闭 Statement，最后关闭 Connection。

8. 总结

通过以上内容，我们详细介绍了使用 JDBC 实现数据库连接的各个方面，包括 JDBC 的基本概念、数据库驱动的类型、连接数据库的基本步骤、完整的代码示例、连接池的使用以及常见问题的解决方法。JDBC 是 Java 开发中与数据库交互的重要技术，熟练掌握它对于开发企业级应用至关重要。在实际开发中，需要根据具体的需求和场景，合理选择数据库驱动、执行对象，并注意资源的管理和性能优化，以确保应用程序能够高效、稳定地运行。