从微服务获取静态资源时遇Socket超时（Read Timeout Exception），如何构建HttpServletResponse？

Got it, let's walk through how to properly handle SocketTimeoutException from your CloseableHttpClient call and build a complete, user-friendly HttpServletResponse. Here's a step-by-step solution tailored to your code:

Step 1: Wrap the proxy execution in a try-catch block #

First, you need to catch the SocketTimeoutException (and other potential IO exceptions) when executing the proxy request. This lets you intercept the timeout before it propagates as an unhandled error.

Step 2: Build the error response #

When a timeout occurs, you'll want to set a meaningful HTTP status code, appropriate headers, and a clear error body for the client. We'll use 504 Gateway Timeout here—it's the standard status code for when a gateway/proxy can't get a response from the upstream server in time, which matches your scenario perfectly.

Full Code Example #

Here's how to integrate this into your existing code:

// Your existing RequestConfig setup
RequestConfig.Builder builder = RequestConfig.custom()
        .setRedirectsEnabled(doHandleRedirects)
        .setCookieSpec(CookieSpecs.IGNORE_COOKIES)
        .setConnectTimeout(connectTimeout)
        .setSocketTimeout(1000);

HttpUriRequest proxyRequest = // ... your existing proxy request setup

try {
    // Execute the proxy request
    CloseableHttpResponse response = proxyClientStaticResource.execute(getTargetHost(servletRequest), proxyRequest);
    // ... your existing logic to process the successful response
} catch (SocketTimeoutException e) {
    // Handle the socket timeout by building a custom response
    handleSocketTimeoutResponse(httpServletResponse);
} catch (IOException e) {
    // Optional: Handle other IO exceptions if needed
    httpServletResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Unexpected error fetching resource");
}

// Helper method to build the timeout response
private void handleSocketTimeoutResponse(HttpServletResponse response) throws IOException {
    // Check if the response is already committed to avoid errors
    if (response.isCommitted()) {
        return;
    }

    // Set appropriate HTTP status code (504 = Gateway Timeout)
    response.setStatus(HttpServletResponse.SC_GATEWAY_TIMEOUT);

    // Configure response headers
    response.setContentType("text/plain; charset=UTF-8");
    response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // Prevent caching error responses
    response.setHeader("Pragma", "no-cache");
    response.setHeader("Expires", "0");

    // Write a clear error message to the response body
    String errorMessage = "Request timed out while fetching static resource. Please try again later.";
    try (PrintWriter writer = response.getWriter()) {
        writer.write(errorMessage);
        writer.flush();
    }
}

Key Notes #

• Status Code Choice: 504 is more accurate than a generic 500 because it explicitly tells clients the timeout happened at the proxy/gateway level waiting for the upstream service.
• Response Headers: Setting Cache-Control headers ensures clients don't cache this error response, which is important for transient timeouts.
• Committed Check: Always check response.isCommitted() before modifying the response—this avoids IllegalStateException if parts of the response were already sent.
• Resource Management: Using try-with-resources for PrintWriter ensures it's properly closed after writing the response body.

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