Spring Boot RestTemplate上传大文件超时问题排查与优化咨询

Hey there! Let's dig into why your RestTemplate is timing out when sending JSON files over 2.5MB, and walk through some optimized fixes tailored to your scenario.

Why the Timeout Happens #

Here are the most common culprits behind this issue:

• Default timeout settings are too short: RestTemplate uses conservative default timeouts (often just a few seconds). Transferring and processing a large JSON file takes longer than these defaults allow, triggering a timeout.
• In-memory loading bottlenecks: If you're loading the entire JSON file into memory before sending, this can cause slowdowns (or even out-of-memory errors) for large files, leading to timeouts mid-request.
• Server-side constraints: Your backend might not be configured to handle large request bodies—either it's cutting off requests early due to size limits, or taking too long to process the full JSON because it's loading everything into memory at once.

Optimized Solutions #

1. Adjust RestTemplate Timeout Configurations #

First, fix the timeout settings by configuring a proper ClientHttpRequestFactory to allow more time for connection and data transfer.

Option A: Basic Configuration with SimpleClientHttpRequestFactory

SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(30000); // 30 seconds for connection setup
factory.setReadTimeout(60000);    // 60 seconds for data transfer/processing
RestTemplate restTemplate = new RestTemplate(factory);

Option B: Flexible Configuration with Apache HttpClient

For better control (like connection pool management), use HttpComponentsClientHttpRequestFactory:

HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
factory.setConnectTimeout(30000);          // Timeout for establishing connection
factory.setConnectionRequestTimeout(30000); // Timeout waiting for a pool connection
factory.setReadTimeout(60000);             // Timeout for reading response data
RestTemplate restTemplate = new RestTemplate(factory);

2. Stream the Request Body Instead of Loading It All Into Memory #

Instead of loading the entire JSON file into memory, stream it directly to the request body. This reduces memory usage and avoids slowdowns from large in-memory objects.

Update your RequestCallback to use streaming:

String requestUrl = "http://localhost:" + port + "/v1/filterLarge";
RequestCallback requestCallback = (ClientHttpRequest request) -> {
    request.getHeaders().setContentType(MediaType.APPLICATION_JSON);
    // Use try-with-resources to auto-close streams
    try (InputStream is = getClass().getClassLoader().getResourceAsStream("data.json");
         OutputStream os = request.getBody()) {
        byte[] buffer = new byte[4096]; // 4KB buffer for efficient streaming
        int bytesRead;
        while ((bytesRead = is.read(buffer)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
    } catch (IOException e) {
        throw new RuntimeException("Failed to stream JSON data to request", e);
    }
};
// Execute the request (adjust the response handler if you need to process a response)
restTemplate.execute(requestUrl, HttpMethod.POST, requestCallback, response -> null);

3. Optimize Server-Side Configuration #

Your backend needs to handle large requests too. If you're using Spring Boot, add these settings to application.properties:

# Allow larger request bodies (adjust size to fit your needs)
server.max-http-request-size=10MB
# Increase Tomcat connection timeout to match client-side settings
server.tomcat.connection-timeout=60000
# Prevent Tomcat from cutting off large requests prematurely
server.tomcat.max-swallow-size=10MB

Also, modify your controller to process JSON streamingly instead of loading it all into memory. This speeds up processing and reduces memory pressure:

@PostMapping("/v1/filterLarge")
public ResponseEntity<Void> filterLarge(@RequestBody InputStream inputStream) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    // Use Jackson's streaming API to parse JSON incrementally
    try (JsonParser parser = objectMapper.getFactory().createParser(inputStream)) {
        JsonToken token;
        while ((token = parser.nextToken()) != null) {
            // Process each JSON token/element here
            if (token == JsonToken.START_OBJECT) {
                // Parse individual object and apply filtering logic
                YourDataObject obj = parser.readValueAs(YourDataObject.class);
                // ... your filtering code ...
            }
        }
    }
    return ResponseEntity.ok().build();
}

4. Switch to WebClient (Recommended for Modern Spring Apps) #

Spring 5+ introduced WebClient, an asynchronous, non-blocking HTTP client that's far more efficient for large file transfers. It uses streaming by default and has better memory management.

Here's how to rewrite your request with WebClient:

WebClient webClient = WebClient.create("http://localhost:" + port);
// Stream the JSON file directly from the classpath
Mono<Void> requestResult = webClient.post()
        .uri("/v1/filterLarge")
        .contentType(MediaType.APPLICATION_JSON)
        .body(BodyInserters.fromResource(new ClassPathResource("data.json")))
        .retrieve()
        .bodyToMono(Void.class);

// For synchronous execution (similar to RestTemplate behavior)
requestResult.block();

// For asynchronous execution (better for non-blocking applications)
// requestResult.subscribe(
//     success -> System.out.println("Request completed successfully!"),
//     error -> System.err.println("Request failed: " + error.getMessage())
// );

Final Tips #

• Monitor request stages: Add logging to track when the request starts, when the connection is established, and when it finishes. This will help you pinpoint if the timeout happens during connection or data transfer.
• Consider chunked transfer: For extremely large files, split the JSON into smaller chunks and send multiple requests (or use HTTP chunked transfer encoding) to avoid single oversized requests.

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