Great question—this is a classic pain point with HTTP streaming once response headers have already been sent. Since we can't retroactively change the HTTP status code after headers are dispatched, we need alternative patterns to signal failure to the client. Here are practical, actionable approaches you can implement:

1. Use HTTP Chunked Encoding with Trailer Headers (HTTP/1.1+) #

HTTP/1.1's chunked transfer encoding allows adding trailer headers at the end of the response body to send metadata (like error status) after streaming content. You first declare the trailer fields in the initial response headers, then write the actual trailer values once streaming completes or fails.

Modified code example:

@GetMapping("/report")
public void generateReport(HttpServletResponse response) throws IOException {
    response.addHeader("Content-Disposition", "attachment; filename=report.json");
    response.addHeader("Content-Type", "application/stream+json");
    response.addHeader("Transfer-Encoding", "chunked");
    // Declare which trailer headers we'll send later
    response.addHeader("Trailer", "X-Stream-Status, X-Stream-Error");
    response.setCharacterEncoding("UTF-8");

    OutputStream out = response.getOutputStream();
    ObjectMapper om = new ObjectMapper();
    long count = 0;
    boolean streamFailed = false;
    String errorDetails = null;

    try {
        count = reportService.findReportData()
                .map(this::transfromEntry)
                .map(entry -> {
                    try {
                        return om.writeValueAsBytes(entry);
                    } catch (JsonProcessingException e) {
                        throw new TransformEntryException("Failed to serialize entry", e);
                    }
                })
                .peek(entry -> {
                    try {
                        out.write(entry);
                        out.flush(); // Ensure chunks are sent immediately
                    } catch (IOException e) {
                        throw new RuntimeException("Stream write failed", e);
                    }
                })
                .count();
    } catch (TransformEntryException e) {
        streamFailed = true;
        errorDetails = e.getMessage();
        LOGGER.error("Failed generating report at entry #{}", count + 1, e);
        // Write error context directly to the stream for client debugging
        byte[] errorPayload = om.writeValueAsBytes(Map.of("stream_error", errorDetails));
        out.write(errorPayload);
        out.flush();
    } finally {
        // Attach trailer headers to signal final status
        if (streamFailed) {
            response.addHeader("X-Stream-Status", "failed");
            response.addHeader("X-Stream-Error", errorDetails);
        } else {
            response.addHeader("X-Stream-Status", "success");
        }
        out.close();
    }

    LOGGER.info("Report generated with {} entries.", count);
}

Caveat: Not all clients support trailer headers—older browsers or basic HTTP download tools might ignore them. This works best if your client is custom-built (e.g., a frontend using fetch API or a desktop app) that can explicitly read trailer data.

2. Write a Contracted Status Marker at the Stream End #

Agree on a special final marker with your client to signal success or failure. For example, if you're using NDJSON (one JSON object per line), append a status object as the last line:

• On success: {"status":"success"}
• On failure: {"status":"error","message":"Failed to process entry #13"}

Clients can then check the final line of the downloaded file to verify completion.

Modified code snippet for this pattern:

// Inside try block (after successful streaming)
byte[] successMarker = om.writeValueAsBytes(Map.of("status", "success"));
out.write(System.lineSeparator().getBytes(StandardCharsets.UTF_8));
out.write(successMarker);
out.flush();

// Inside catch block (on failure)
byte[] errorMarker = om.writeValueAsBytes(Map.of("status", "error", "message", errorDetails));
out.write(System.lineSeparator().getBytes(StandardCharsets.UTF_8));
out.write(errorMarker);
out.flush();

This is the most compatible approach—works with any client that can read the downloaded file content, though it requires client-side code to validate the final marker.

3. Switch to WebSocket Streaming (If Scenario Allows) #

If you can adjust your client-server communication pattern, WebSockets offer bidirectional messaging. If a failure occurs mid-stream, the server can immediately send an error message to the client, which can then interrupt the download and notify the user in real time.

This approach is more robust for error handling but requires rewriting both server and client logic to use WebSocket instead of HTTP streaming.

4. Pre-Validate Data (Reduce Mid-Stream Failures) #

For smaller datasets, pre-validate all entries before starting the stream:

// Pre-check all entries first
List<ReportEntry> validatedEntries = reportService.findReportData()
        .map(this::transfromEntry)
        .collect(Collectors.toList());

// Stream only if pre-validation passes
validatedEntries.stream()
        .map(entry -> om.writeValueAsBytes(entry))
        .peek(out::write)
        .count();

This eliminates mid-stream failures but isn't feasible for very large datasets (as it loads all data into memory).

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