如何让Java Spring Boot应用作为隧道分块传输远程存储大文件？

完全可以实现这种流式转发的隧道模式，不需要将文件本地存储或加载到内存——核心是利用流式IO和Spring的相关特性实现分块传输，让客户端获得接近直接从远程存储下载的体验。

核心思路 #

• 从远程存储（如S3）获取文件的输入流，不一次性读取全部内容
• 将输入流直接写入Spring的响应输出流，每读取一块就立刻返回给客户端
• 设置正确的响应头，让客户端感知文件的大小、类型等信息，保证下载体验

实现方案 #

1. 传统Spring MVC（同步流式转发） #

适合基于Servlet的Spring Boot应用，用标准IO流实现分块传输：

@RestController
@RequestMapping("/download")
public class FileDownloadController {

    private final AmazonS3 s3Client; // 已配置完成的S3客户端

    public FileDownloadController(AmazonS3 s3Client) {
        this.s3Client = s3Client;
    }

    @GetMapping("/{bucket}/{key}")
    public void downloadFile(@PathVariable String bucket, 
                             @PathVariable String key, 
                             HttpServletResponse response) throws IOException {
        // 从S3获取元数据，设置响应头
        ObjectMetadata metadata = s3Client.getObjectMetadata(bucket, key);
        response.setContentType(metadata.getContentType());
        response.setContentLength((int) metadata.getContentLength());
        response.setHeader("Content-Disposition", 
                          "attachment; filename=\"" + key.substring(key.lastIndexOf('/') + 1) + "\"");

        // 流式读取S3文件并写入响应输出流
        try (S3Object s3Object = s3Client.getObject(bucket, key);
             InputStream inputStream = s3Object.getObjectContent();
             OutputStream outputStream = response.getOutputStream()) {

            byte[] buffer = new byte[8192]; // 8KB分块，可根据网络情况调整
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
                outputStream.flush(); // 确保块立即发送给客户端
            }
        } catch (AmazonServiceException e) {
            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            response.getWriter().write("获取文件失败：" + e.getMessage());
        }
    }
}

关键细节：

• 用try-with-resources自动管理流的关闭，避免资源泄漏
• 8KB缓冲区是平衡内存占用和IO性能的常用值，可根据实际场景调整
• 每次读取后立刻flush输出流，确保数据及时发送，不会在服务端堆积

2. Spring WebFlux（非阻塞流式转发） #

如果是响应式Spring Boot应用，用WebFlux的天然流式特性实现非阻塞传输：

@RestController
@RequestMapping("/download")
public class ReactiveFileDownloadController {

    private final S3AsyncClient s3AsyncClient; // 异步S3客户端

    public ReactiveFileDownloadController(S3AsyncClient s3AsyncClient) {
        this.s3AsyncClient = s3AsyncClient;
    }

    @GetMapping("/{bucket}/{key}")
    public ResponseEntity<Flux<DataBuffer>> downloadFile(@PathVariable String bucket, 
                                                        @PathVariable String key) {
        // 获取文件元数据
        GetObjectMetadataRequest metadataRequest = GetObjectMetadataRequest.builder()
                .bucket(bucket)
                .key(key)
                .build();

        return s3AsyncClient.getObjectMetadata(metadataRequest)
                .map(metadata -> {
                    // 构建响应头
                    HttpHeaders headers = new HttpHeaders();
                    headers.setContentType(MediaType.parseMediaType(metadata.contentType()));
                    headers.setContentLength(metadata.contentLength());
                    headers.setContentDisposition(ContentDisposition.attachment()
                            .filename(key.substring(key.lastIndexOf('/') + 1))
                            .build());

                    // 流式获取S3文件内容，转换为响应式数据流
                    GetObjectRequest getRequest = GetObjectRequest.builder()
                            .bucket(bucket)
                            .key(key)
                            .build();

                    Flux<DataBuffer> dataBufferFlux = DataBufferUtils.readInputStream(
                            () -> s3AsyncClient.getObject(getRequest).join().responseBody(),
                            new DefaultDataBufferFactory(),
                            8192);

                    return ResponseEntity.ok()
                            .headers(headers)
                            .body(dataBufferFlux);
                })
                .onErrorResume(e -> ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                        .body(Flux.just(DefaultDataBufferFactory.sharedInstance.wrap(
                                ("获取文件失败：" + e.getMessage()).getBytes()))));
    }
}

关键细节：

• Flux<DataBuffer>天然支持分块传输，无需手动flush
• 异步S3客户端配合响应式API，不会阻塞服务端线程，适合高并发场景

重要注意事项 #

• 响应头必须正确设置：Content-Length让客户端显示下载进度；Content-Type确保浏览器正确处理文件；Content-Disposition控制是下载附件还是在线预览
• 缓冲区大小合理调整：不要过大（避免内存占用过高）也不要过小（增加IO次数），8KB~64KB是常规选择
• 异常处理要及时：捕获远程存储的访问异常（如权限不足、文件不存在），返回明确的HTTP状态码和错误信息，避免客户端无限等待
• 超时配置：给远程存储客户端（如S3客户端）设置合理的超时时间，防止服务端线程被长时间阻塞
• 无文件大小场景：如果无法获取文件总大小（如动态生成的文件），可以启用Transfer-Encoding: chunked，Spring会自动处理，此时无需设置Content-Length

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