基于Java 7与Spring MVC 3.2实现REST流式返回资源的咨询

Absolutely! You can absolutely implement streaming resource transfer without loading the entire file into memory using Java 7 and Spring MVC 3.2. Here's how to approach this, including key research directions and practical code examples:

Spring MVC 3.2 fully supports streaming responses by directly writing to the HttpServletResponse's output stream. Java 7's IO APIs also handle chunked reading/writing perfectly, so this is totally achievable.

• Direct Output Stream Manipulation: Focus on how to use HttpServletResponse.getOutputStream() to write data incrementally—this is the foundation of streaming in Spring MVC.
• Chunked IO in Java 7: Learn to use byte buffers with InputStream.read(byte[]) and OutputStream.write(byte[], int, int) to transfer data in chunks, avoiding full memory loading.
• Response Header Configuration: Research headers like Content-Type (to specify resource type), Content-Disposition (for file downloads), and Transfer-Encoding: chunked (to notify clients of streaming).
• Resource Cleanup: Understand proper closing of streams and connections in Java 7—try-with-resources is supported (since Java 7) to simplify this, or manual cleanup in finally blocks.

Here's how to adapt your existing code to stream data end-to-end:

Controller Layer #

Modify your controller method to directly interact with the response output stream (return void since we're writing directly to the response):

@RequestMapping(value = "/attachment", method = RequestMethod.GET)
public void getTrademarkAttachment(HttpServletResponse response, HttpServletRequest request) {
    try {
        // Configure response headers based on your resource type
        response.setContentType("application/octet-stream"); // Adjust for images/docs (e.g., "image/jpeg", "application/pdf")
        response.setHeader("Content-Disposition", "attachment; filename=\"trademark-document.pdf\""); // For downloads
        response.setHeader("Transfer-Encoding", "chunked");

        // Stream data to the client
        yourAttachmentService.streamAttachmentToResponse(response.getOutputStream());

        // Ensure all data is sent
        response.getOutputStream().flush();
    } catch (IOException e) {
        // Handle errors gracefully
        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        e.printStackTrace();
    }
}

Service Layer #

Update your service method to write directly to the response output stream instead of returning a byte[]—note: avoid BufferedReader/InputStreamReader for binary data (images, docs) as they corrupt non-text content:

public void streamAttachmentToResponse(OutputStream outputStream) throws IOException {
    String urlSample = "http://testUrl.com";
    HttpURLConnection httpConn = null;
    InputStream inputStream = null;

    try {
        httpConn = (HttpURLConnection) new URL(urlSample).openConnection();
        inputStream = httpConn.getInputStream();

        // Use a buffer for chunked transfer (4KB is a balanced size)
        byte[] buffer = new byte[4096];
        int bytesRead;

        // Read in chunks and write immediately to the response
        while ((bytesRead = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
            outputStream.flush(); // Push data to client immediately
        }
    } catch (MalformedURLException e) {
        throw new IOException("Invalid attachment URL", e);
    } finally {
        // Clean up resources properly
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (httpConn != null) {
            httpConn.disconnect();
        }
    }
}

• Binary Data Handling: Never use character-based readers (like BufferedReader) for binary resources (images, PDFs)—they will mangle the data. Stick to raw InputStream/OutputStream.
• Buffer Size: Adjust the buffer size (e.g., 4KB, 8KB) based on your resource size and memory constraints—larger buffers reduce IO calls but use more memory temporarily.
• Exception Handling: Always catch IO exceptions and set appropriate HTTP status codes (e.g., 500 for server errors) to prevent clients from hanging.
• Interceptor Checks: Ensure no Spring MVC interceptors are buffering the entire response (some logging or security interceptors may do this)—verify that interceptors pass through the stream without caching.

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