使用 HttpURLConnection 处理HTTP错误响应体并获取详细信息

public static String sendPostRequest(String requestUrl, String payload, Map<String, String> requestProperties) {
    StringBuffer jsonString = new StringBuffer();
    try {
        URL url = new URL(requestUrl);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setDoInput(true);
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        for (Map.Entry<String, String> entry : requestProperties.entrySet()) {
            connection.setRequestProperty(entry.getKey(), entry.getValue());
        }

        OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream(), StandardCharsets.UTF_8);
        writer.write(payload);
        writer.close();

        // 问题在于这里：直接使用 getInputStream()
        BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            jsonString.append(line);
        }
        br.close();
        connection.disconnect();

    } catch (Exception e) {
        // 当状态码为4xx/5xx时，getInputStream() 会抛出异常，导致无法获取响应体
        // 并且异常信息可能无法提供足够的错误细节
        log.error("Error for call " + requestUrl, e);
    }
    return jsonString.toString();
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Map;

public class HttpUtil {

    // 假设存在一个日志记录器
    private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(HttpUtil.class);

    public static String sendPostRequest(String requestUrl, String payload, Map<String, String> requestProperties) {
        StringBuilder responseBody = new StringBuilder();
        HttpURLConnection connection = null;
        try {
            URL url = new URL(requestUrl);
            connection = (HttpURLConnection) url.openConnection();

            connection.setDoInput(true);
            connection.setDoOutput(true);
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json"); // 示例：设置Content-Type
            connection.setRequestProperty("Accept", "application/json");     // 示例：设置Accept

            for (Map.Entry<String, String> entry : requestProperties.entrySet()) {
                connection.setRequestProperty(entry.getKey(), entry.getValue());
            }

            // 发送请求体
            try (OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream(), StandardCharsets.UTF_8)) {
                writer.write(payload);
                writer.flush(); // 确保所有数据都已写入
            }

            // 获取响应状态码
            int responseCode = connection.getResponseCode();
            log.info("Response Code for {}: {}", requestUrl, responseCode);

            InputStream inputStream;
            // 根据状态码选择获取输入流的方式
            if (responseCode >= 200 && responseCode < 400) {
                // 成功或重定向响应，使用 getInputStream()
                inputStream = connection.getInputStream();
            } else {
                // 4xx 或 5xx 错误响应，使用 getErrorStream()
                inputStream = connection.getErrorStream();
                if (inputStream == null) {
                    // 如果错误流也为空，可能是没有错误体，或者连接已关闭
                    log.warn("Error stream is null for response code {}. No error body available.", responseCode);
                    return ""; // 返回空字符串或根据业务逻辑处理
                }
            }

            // 读取响应体
            try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
                String line;
                while ((line = br.readLine()) != null) {
                    responseBody.append(line);
                }
            }

            // 记录或处理错误响应
            if (responseCode >= 400) {
                log.error("API call to {} failed with status code {}. Response body: {}", requestUrl, responseCode, responseBody.toString());
            }

        } catch (IOException e) {
            log.error("IO Error during API call to " + requestUrl, e);
        } catch (Exception e) {
            log.error("Unexpected Error during API call to " + requestUrl, e);
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
        return responseBody.toString();
    }

    public static void main(String[] args) {
        // 示例用法：假设有一个成功的API和失败的API
        // 成功请求示例
        String successUrl = "https://jsonplaceholder.typicode.com/posts";
        String successPayload = "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}";
        Map<String, String> successHeaders = Map.of("Content-Type", "application/json");
        System.out.println("--- Successful Request ---");
        String successResponse = sendPostRequest(successUrl, successPayload, successHeaders);
        System.out.println("Success Response: " + successResponse);
        System.out.println("\n");

        // 失败请求示例 (假设这个URL会返回404或类似错误)
        // 注意：jsonplaceholder.typicode.com/posts/999999 可能会返回404，但POST请求到 /posts 通常返回201
        // 为了模拟400+错误，我们可能需要一个实际会返回错误的API
        // 这里以一个不存在的路径来模拟404
        String errorUrl = "https://jsonplaceholder.typicode.com/nonexistent-path"; // 模拟404
        String errorPayload = "{}";
        Map<String, String> errorHeaders = Map.of("Content-Type", "application/json");
        System.out.println("--- Error Request (simulated 404) ---");
        String errorResponse = sendPostRequest(errorUrl, errorPayload, errorHeaders);
        System.out.println("Error Response: " + errorResponse);
    }
}