在Java中使用JDBC查询数据库并处理结果集

在Java中使用JDBC查询数据库并处理结果集

在Java应用程序中，使用JDBC进行数据库查询和处理结果集是常见的需求。然而，直接使用JDBC创建和关闭数据库连接可能会带来性能问题。每次创建和关闭连接都是一个开销较大的操作。为了提高数据库访问性能，可以使用连接池来管理数据库连接。本文将介绍如何使用JDBC进行数据库查询并处理结果集，以及如何通过连接池（如HikariCP）来优化Java应用程序中的数据库访问。

使用JDBC进行数据库查询和处理结果集

首先，来看一个使用JDBC进行数据库查询和处理结果集的示例。假设有一个RoleService类，其中包含一些基本的数据库操作方法，如获取所有角色、根据用户ID获取角色名称、删除角色和添加新角色。

package com.atguigu.admin.service;

import com.atguigu.admin.bean.Role;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class RoleService {

    /**
     * 获取所有角色
     */
    public static List<Role> getAllRoles() {
        try {
            Class.forName(DATABASE.DRIVER);
            Connection connection = DriverManager.getConnection(DATABASE.URL, DATABASE.USERNAME, DATABASE.PASSWORD);
            PreparedStatement selectStatement = connection.prepareStatement(
                    "SELECT id, role_name FROM role"
            );
            List<Role> roles = new ArrayList<>();
            ResultSet resultSet = selectStatement.executeQuery();
            while (resultSet.next()) {
                Role role = new Role();
                role.setId(resultSet.getLong("id"));
                role.setRoleName(resultSet.getString("role_name"));
                roles.add(role);
            }
            selectStatement.close();
            connection.close();
            return roles;
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();
    }

    /**
     * 根据用户ID获取对应的角色名称
     */
    public static String getUserRoleName(Long userId) {
        try {
            Class.forName(DATABASE.DRIVER);
            Connection connection = DriverManager.getConnection(DATABASE.URL, DATABASE.USERNAME, DATABASE.PASSWORD);
            PreparedStatement selectStatement = connection.prepareStatement(
                    "SELECT role.role_name AS roleName FROM user_role" +
                            "  INNER JOIN role ON user_role.role_id = role.id" +
                            "  WHERE user_role.user_id = ?"
            );
            selectStatement.setLong(1, userId);
            ResultSet resultSet = selectStatement.executeQuery();
            String roleName = "";
            if (resultSet.next()) {
                roleName = resultSet.getString("roleName");
            }

            selectStatement.close();
            connection.close();
            return roleName;
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 删除角色
     */
    public static void deleteRole(Long roleId) {
        try {
            Class.forName(DATABASE.DRIVER);
            Connection connection = DriverManager.getConnection(DATABASE.URL, DATABASE.USERNAME, DATABASE.PASSWORD);

            PreparedStatement deleteRoleStatement = connection.prepareStatement(
                    "DELETE FROM role WHERE id = ?"
            );
            deleteRoleStatement.setLong(1, roleId);
            deleteRoleStatement.execute();

            PreparedStatement deleteRolePermissionStatement = connection.prepareStatement(
                    "DELETE FROM role_permission WHERE role_id = ?"
            );
            deleteRolePermissionStatement.setLong(1, roleId);
            deleteRolePermissionStatement.execute();

            PreparedStatement deleteUserRoleStatement = connection.prepareStatement(
                    "DELETE FROM user_role WHERE role_id = ?"
            );
            deleteUserRoleStatement.setLong(1, roleId);
            deleteUserRoleStatement.execute();

            deleteRoleStatement.close();
            deleteRolePermissionStatement.close();
            deleteUserRoleStatement.close();
            connection.close();
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加新角色
     */
    public static void addRole(String roleName) {
        try {
            Class.forName(DATABASE.DRIVER);
            Connection connection = DriverManager.getConnection(DATABASE.URL, DATABASE.USERNAME, DATABASE.PASSWORD);
            PreparedStatement insertStatement = connection.prepareStatement(
                    "INSERT INTO role (role_name) VALUES (?)"
            );
            insertStatement.setString(1, roleName);
            insertStatement.execute();

            insertStatement.close();
            connection.close();
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，直接使用JDBC进行数据库操作。每次操作都需要创建和关闭连接，这会带来较大的开销。为了解决这个问题，可以使用连接池来管理数据库连接。

通过连接池提高数据库访问性能

连接池（Connection Pool）是一种资源池化技术，用于管理数据库连接。它通过维护一组预先创建的数据库连接，并在需要时将这些连接提供给应用程序。当应用程序不再需要连接时，连接被返回到池中，以供将来的请求使用。连接池可以显著减少连接创建和关闭的开销，提高应用程序的性能。

HikariCP是一个高性能的JDBC连接池库，广泛用于Java应用程序中。它以其高效、轻量级和简单的配置而闻名。以下是如何在Java应用程序中集成HikariCP连接池的示例。

添加依赖

首先，需要在项目中添加HikariCP的依赖。如果使用Maven，可以在pom.xml中添加以下依赖：

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

如果使用Gradle，可以在build.gradle中添加以下依赖：

implementation 'com.zaxxer:HikariCP:5.0.1'

配置HikariCP

接下来，需要配置HikariCP连接池。以下是一个简单的配置示例：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import javax.sql.DataSource;

public class DataSourceConfig {

    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase");
        config.setUsername("root");
        config.setPassword("password");
        config.setDriverClassName("com.mysql.cj.jdbc.Driver");
        
        // 可选配置
        config.setMaximumPoolSize(10);  // 最大连接数
        config.setMinimumIdle(5);       // 最小空闲连接数
        config.setIdleTimeout(30000);   // 空闲超时时间（毫秒）
        config.setConnectionTimeout(30000);  // 连接超时时间（毫秒）
        config.setMaxLifetime(1800000); // 连接的最大生命周期（毫秒）

        dataSource = new HikariDataSource(config);
    }

    public static DataSource getDataSource() {
        return dataSource;
    }
}

使用连接池

在的代码中，可以使用配置好的DataSource来获取数据库连接，并进行数据库操作。以下是一个使用HikariCP连接池的示例：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserService {

    public List<User> fetchUsers() {
        List<User> users = new ArrayList<>();
        String query = "SELECT id, name, email FROM users";

        try (Connection connection = DataSourceConfig.getDataSource().getConnection();
             PreparedStatement statement = connection.prepareStatement(query);
             ResultSet resultSet = statement.executeQuery()) {

            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String email = resultSet.getString("email");
                users.add(new User(id, name, email));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return users;
    }

    public static void main(String[] args) {
        UserService userService = new UserService();
        List<User> users = userService.fetchUsers();
        users.forEach(user -> System.out.println(user.getId() + ": " + user.getName() + " - " + user.getEmail()));
    }
}

分步解析

1. 配置连接池：
   在DataSourceConfig类中，通过HikariConfig配置连接池参数，并创建HikariDataSource实例。

2. 获取连接：
   在需要数据库操作的地方，通过DataSourceConfig.getDataSource().getConnection()获取连接。连接池会自动管理连接的创建和复用。

3. 执行查询：
   使用获取到的连接进行查询操作，并处理结果集。

4. 自动关闭资源：
   使用try-with-resources语句确保在完成操作后自动关闭连接、语句和结果集。

优点

使用连接池有以下优点：

1. 性能提升：减少了连接创建和关闭的开销，显著提高了性能。
2. 资源管理：连接池自动管理连接的复用和释放，优化了资源使用。
3. 简化代码：开发者无需手动管理连接的创建和关闭，简化了代码。

结论

在生产环境中，使用连接池是提高数据库访问性能的最佳实践。通过配置和使用HikariCP连接池，可以显著减少连接创建和关闭的开销，提高应用程序的性能和可扩展性。