如何通过JDBC在Java中对SQL Server实现批量多条件查询？

针对你遇到的批量查询性能问题，以下是几个适配SQL Server + JDBC的高效可行方案：

方案一：使用SQL Server表值参数（TVP） #

这是SQL Server官方推荐的批量参数传递方案，完美支持多列批量查询，性能最优，且无需担心SQL语句长度限制。

步骤： #

1. 在SQL Server中创建用户定义表类型：

CREATE TYPE dbo.MyParamType AS TABLE (
    COLUMN_A INT, -- 替换为你的实际字段类型
    COLUMN_B VARCHAR(50),
    COLUMN_C DATETIME
);

2. JDBC代码实现：

// 1. 初始化表值参数结构
SQLServerDataTable tvpTable = new SQLServerDataTable();
tvpTable.addColumnMetadata("COLUMN_A", java.sql.Types.INTEGER);
tvpTable.addColumnMetadata("COLUMN_B", java.sql.Types.VARCHAR);
tvpTable.addColumnMetadata("COLUMN_C", java.sql.Types.TIMESTAMP);

// 2. 将ArrayList中的对象数据填入表值参数
for (YourObject obj : yourArrayList) {
    tvpTable.addRow(obj.getColumnA(), obj.getColumnB(), obj.getColumnC());
}

// 3. 执行关联查询，同时带回原参数用于匹配对象
String sql = "SELECT t.INFO_X, t.INFO_Y, p.COLUMN_A, p.COLUMN_B, p.COLUMN_C " +
             "FROM TABLE t " +
             "JOIN @ParamTable p ON t.COLUMN_A = p.COLUMN_A AND t.COLUMN_B = p.COLUMN_B AND t.COLUMN_C = p.COLUMN_C";

// 提前构建对象映射，方便后续结果匹配
Map<String, YourObject> keyMap = new HashMap<>();
for (YourObject obj : yourArrayList) {
    String key = obj.getColumnA() + "_" + obj.getColumnB() + "_" + obj.getColumnC();
    keyMap.put(key, obj);
}

try (Connection conn = getConnection();
     SQLServerPreparedStatement pstmt = (SQLServerPreparedStatement) conn.prepareStatement(sql)) {
    // 设置表值参数
    pstmt.setStructured(1, "dbo.MyParamType", tvpTable);
    
    // 处理查询结果
    try (ResultSet rs = pstmt.executeQuery()) {
        while (rs.next()) {
            String key = rs.getInt("COLUMN_A") + "_" + rs.getString("COLUMN_B") + "_" + rs.getTimestamp("COLUMN_C");
            YourObject target = keyMap.get(key);
            if (target != null) {
                target.setInfoX(rs.getString("INFO_X"));
                target.setInfoY(rs.getInt("INFO_Y"));
            }
        }
    }
} catch (SQLException e) {
    e.printStackTrace();
}

优点：单次数据库交互，性能拉满；支持任意规模的批量参数；代码简洁易维护。
注意：需使用Microsoft官方的sqljdbc42.jar及以上版本，确保驱动支持表值参数。

方案二：分批次构造多条件查询 #

如果无法使用表值参数，可以将16000个对象拆分为多个小批次（比如每批次1000个），每个批次构造OR连接的多条件查询，避免SQL语句过长。

示例代码： #

int batchSize = 1000;
int total = yourArrayList.size();

// 提前构建对象映射
Map<String, YourObject> keyMap = new HashMap<>();
for (YourObject obj : yourArrayList) {
    String key = obj.getColumnA() + "_" + obj.getColumnB() + "_" + obj.getColumnC();
    keyMap.put(key, obj);
}

// 分批次处理
for (int i = 0; i < total; i += batchSize) {
    int end = Math.min(i + batchSize, total);
    List<YourObject> batch = yourArrayList.subList(i, end);
    
    // 构造当前批次的SQL语句
    StringBuilder sqlBuilder = new StringBuilder("SELECT INFO_X, INFO_Y, COLUMN_A, COLUMN_B, COLUMN_C FROM TABLE WHERE ");
    List<Object> params = new ArrayList<>();
    
    for (int j = 0; j < batch.size(); j++) {
        if (j > 0) {
            sqlBuilder.append(" OR ");
        }
        sqlBuilder.append("(COLUMN_A = ? AND COLUMN_B = ? AND COLUMN_C = ?)");
        YourObject obj = batch.get(j);
        params.add(obj.getColumnA());
        params.add(obj.getColumnB());
        params.add(obj.getColumnC());
    }
    
    // 执行当前批次查询
    try (Connection conn = getConnection();
         PreparedStatement pstmt = conn.prepareStatement(sqlBuilder.toString())) {
        for (int j = 0; j < params.size(); j++) {
            pstmt.setObject(j + 1, params.get(j));
        }
        try (ResultSet rs = pstmt.executeQuery()) {
            while (rs.next()) {
                String key = rs.getInt("COLUMN_A") + "_" + rs.getString("COLUMN_B") + "_" + rs.getTimestamp("COLUMN_C");
                YourObject target = keyMap.get(key);
                if (target != null) {
                    target.setInfoX(rs.getString("INFO_X"));
                    target.setInfoY(rs.getInt("INFO_Y"));
                }
            }
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

优点：无需修改数据库结构，兼容性好；拆分批次后规避SQL长度限制。
缺点：需要多次数据库交互，性能略逊于TVP；批次大小需根据实际情况调整（建议500-2000之间）。

方案三：临时表插入+关联查询 #

先将所有参数插入临时表，再通过JOIN查询目标表，最后匹配回原对象。

示例代码： #

try (Connection conn = getConnection()) {
    // 1. 创建会话级临时表
    String createTempSql = "CREATE TABLE #TempParams (COLUMN_A INT, COLUMN_B VARCHAR(50), COLUMN_C DATETIME)";
    try (Statement stmt = conn.createStatement()) {
        stmt.execute(createTempSql);
    }
    
    // 2. 批量插入参数到临时表
    String insertSql = "INSERT INTO #TempParams (COLUMN_A, COLUMN_B, COLUMN_C) VALUES (?, ?, ?)";
    try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
        int count = 0;
        for (YourObject obj : yourArrayList) {
            pstmt.setInt(1, obj.getColumnA());
            pstmt.setString(2, obj.getColumnB());
            pstmt.setTimestamp(3, obj.getColumnC());
            pstmt.addBatch();
            count++;
            // 每1000条执行一次批量插入
            if (count % 1000 == 0) {
                pstmt.executeBatch();
            }
        }
        // 执行剩余批次
        pstmt.executeBatch();
    }
    
    // 3. 关联查询目标表
    String querySql = "SELECT t.INFO_X, t.INFO_Y, p.COLUMN_A, p.COLUMN_B, p.COLUMN_C " +
                      "FROM TABLE t " +
                      "JOIN #TempParams p ON t.COLUMN_A = p.COLUMN_A AND t.COLUMN_B = p.COLUMN_B AND t.COLUMN_C = p.COLUMN_C";
    
    // 构建对象映射
    Map<String, YourObject> keyMap = new HashMap<>();
    for (YourObject obj : yourArrayList) {
        String key = obj.getColumnA() + "_" + obj.getColumnB() + "_" + obj.getColumnC();
        keyMap.put(key, obj);
    }
    
    // 处理查询结果
    try (PreparedStatement pstmt = conn.prepareStatement(querySql);
         ResultSet rs = pstmt.executeQuery()) {
        while (rs.next()) {
            String key = rs.getInt("COLUMN_A") + "_" + rs.getString("COLUMN_B") + "_" + rs.getTimestamp("COLUMN_C");
            YourObject target = keyMap.get(key);
            if (target != null) {
                target.setInfoX(rs.getString("INFO_X"));
                target.setInfoY(rs.getInt("INFO_Y"));
            }
        }
    }
} catch (SQLException e) {
    e.printStackTrace();
}

优点：适合超大规模批量查询；逻辑清晰直观。
缺点：需要创建临时表，增加数据库操作步骤；会话级临时表会在连接关闭时自动销毁，无需手动删除。

内容的提问来源于stack exchange，提问作者Zimeon