java对MySQL数据库的封装工具类

在Java中，针对MySQL数据库的封装工具类通常用于简化数据库操作，避免重复编写JDBC代码，提高开发效率和代码可维护性。以下是一个典型的针对MySQL数据库封装的工具类示例，包括数据库连接、查询、插入、更新、删除等常用操作。

1. 数据库连接工具类

首先，我们需要一个数据库连接工具类，这个工具类负责获取数据库连接并释放资源。

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

public class MySQLConnectionUtil {
    
    private static final String URL = "jdbc:mysql://localhost:3306/your_database_name";
    private static final String USER = "your_username";
    private static final String PASSWORD = "your_password";
    private static final String DRIVER_CLASS = "com.mysql.cj.jdbc.Driver";
    
    static {
        try {
            // 加载MySQL JDBC驱动
            Class.forName(DRIVER_CLASS);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    // 获取数据库连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }
    
    // 关闭连接
    public static void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 封装JDBC操作工具类

接下来，我们需要一个封装常见CRUD操作（增、删、改、查）的工具类。

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

public class MySQLUtil {
    
    // 查询方法
    public static <T> List<T> query(String sql, Object[] params, ResultSetHandler<T> handler) {
        List<T> result = new ArrayList<>();
        try (Connection conn = MySQLConnectionUtil.getConnection();
             PreparedStatement psmt = conn.prepareStatement(sql)) {

            // 设置参数
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    psmt.setObject(i + 1, params[i]);
                }
            }

            // 执行查询
            try (ResultSet rs = psmt.executeQuery()) {
                while (rs.next()) {
                    result.add(handler.handle(rs));  // 将每行记录转换为对象
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    // 插入/更新/删除方法
    public static int update(String sql, Object[] params) {
        int rowsAffected = 0;
        try (Connection conn = MySQLConnectionUtil.getConnection();
             PreparedStatement psmt = conn.prepareStatement(sql)) {

            // 设置参数
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    psmt.setObject(i + 1, params[i]);
                }
            }

            // 执行更新操作
            rowsAffected = psmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rowsAffected;
    }

    // 执行查询，返回单个值
    public static <T> T querySingleValue(String sql, Object[] params) {
        T result = null;
        try (Connection conn = MySQLConnectionUtil.getConnection();
             PreparedStatement psmt = conn.prepareStatement(sql)) {

            // 设置参数
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    psmt.setObject(i + 1, params[i]);
                }
            }

            // 执行查询
            try (ResultSet rs = psmt.executeQuery()) {
                if (rs.next()) {
                    result = (T) rs.getObject(1);  // 获取结果的第一列
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }
    
    // 执行批量更新
    public static int[] batchUpdate(String sql, List<Object[]> paramsList) {
        int[] result = null;
        try (Connection conn = MySQLConnectionUtil.getConnection();
             PreparedStatement psmt = conn.prepareStatement(sql)) {

            // 执行批量操作
            for (Object[] params : paramsList) {
                for (int i = 0; i < params.length; i++) {
                    psmt.setObject(i + 1, params[i]);
                }
                psmt.addBatch();
            }

            result = psmt.executeBatch();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }
}

3. 处理查询结果的 ResultSetHandler 接口

由于查询操作返回的结果可能是不同的类型，我们可以通过一个接口来处理查询结果的转换。

import java.sql.ResultSet;
import java.sql.SQLException;

public interface ResultSetHandler<T> {
    T handle(ResultSet rs) throws SQLException;
}

你可以根据需要实现这个接口，例如将查询结果转换为对象：

public class UserHandler implements ResultSetHandler<User> {
    @Override
    public User handle(ResultSet rs) throws SQLException {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
        return user;
    }
}

4. 使用工具类

你可以通过如下方式使用封装好的工具类：

public class MySQLExample {
    public static void main(String[] args) {
        // 查询操作
        String sql = "SELECT * FROM users WHERE id = ?";
        Object[] params = {1};
        
        List<User> users = MySQLUtil.query(sql, params, new UserHandler());
        for (User user : users) {
            System.out.println(user);
        }

        // 插入操作
        String insertSql = "INSERT INTO users (name, email) VALUES (?, ?)";
        Object[] insertParams = {"John Doe", "john@example.com"};
        int rowsInserted = MySQLUtil.update(insertSql, insertParams);
        System.out.println("Rows inserted: " + rowsInserted);
        
        // 更新操作
        String updateSql = "UPDATE users SET email = ? WHERE id = ?";
        Object[] updateParams = {"new_email@example.com", 1};
        int rowsUpdated = MySQLUtil.update(updateSql, updateParams);
        System.out.println("Rows updated: " + rowsUpdated);

        // 删除操作
        String deleteSql = "DELETE FROM users WHERE id = ?";
        Object[] deleteParams = {1};
        int rowsDeleted = MySQLUtil.update(deleteSql, deleteParams);
        System.out.println("Rows deleted: " + rowsDeleted);
    }
}

5. User 类（示例）

User 类是用来映射查询结果的一个简单类，你可以根据自己的需求进行扩展：

public class User {
    private int id;
    private String name;
    private String email;
    
    // Getters and Setters
    
    @Override
    public String toString() {
        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";
    }
}

---

总结

这个封装工具类的设计有以下特点：

• 通用性：MySQLUtil 类可以处理任何查询、插入、更新、删除等数据库操作，提供了足够的灵活性。
• 可扩展性：通过 ResultSetHandler 接口，可以非常方便地将查询结果映射为不同类型的对象。
• 批量操作：batchUpdate 方法支持批量插入、更新等操作。

此工具类封装了 JDBC 相关的常用操作，能够大大简化数据库操作的代码，减少冗余，提高代码的可维护性。