从Amazon S3读取大体积CSV文件出现Socket异常如何解决？

根本原因 #

• 你当前的实现是单次GetObject获取整个文件的输入流，逐行读取时每行会休眠5秒模拟业务处理耗时，导致单个HTTP连接长时间处于空闲状态。AWS的边缘负载均衡、NAT网关等中间网络设备会主动切断空闲超过300~600秒的连接，该逻辑不受客户端TCP keepalive配置影响：默认系统TCP keepalive探测间隔为2小时，远大于中间设备的连接超时阈值，无法阻止连接被回收。
• 配置socketTimeout=0仅代表客户端不主动触发读超时，无法干预服务端/中间设备主动切断连接的行为。

最优解决方案：分段范围请求读取 #

利用S3原生支持的HTTP Range请求能力，不一次性打开整个文件的输入流，每次仅请求固定大小的文件块（推荐16MB~32MB，可根据单块处理耗时调整），处理完当前块的所有行后再请求下一块，避免单连接长时间空闲。需要额外处理跨块的不完整行：将当前块末尾的不完整行缓存，和下一个块的开头内容拼接后再解析。

示例实现代码 #

public class ReadS3File {
    // 每次请求的块大小，可根据实际情况调整
    private static final long CHUNK_SIZE = 16 * 1024 * 1024;
    private static final Regions clientRegion = Regions.US_WEST_2;
    private static final String bucketName = "test-bucket";
    private static final String key = "Unsaved/test.csv";
    private static final String accessKey = "accessKey";
    private static final String secretKey = "secretKey";

    public static void main(String[] args) {
        AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
        AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                .withRegion(clientRegion)
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .build();
        // 获取文件总大小
        long fileLength = s3Client.getObjectMetadata(bucketName, key).getContentLength();
        long offset = 0;
        // 缓存上一个块末尾的不完整行
        String leftover = "";
        int lineCount = 0;
        long startTime = System.nanoTime();

        try {
            while (offset < fileLength) {
                long end = Math.min(offset + CHUNK_SIZE - 1, fileLength - 1);
                GetObjectRequest rangeRequest = new GetObjectRequest(bucketName, key)
                        .withRange(offset, end);
                try (S3Object chunk = s3Client.getObject(rangeRequest);
                     BufferedReader reader = new BufferedReader(new InputStreamReader(chunk.getObjectContent()))) {

                    String line;
                    // 先拼上之前的剩余内容
                    if (!leftover.isEmpty()) {
                        String firstLine = reader.readLine();
                        if (firstLine != null) {
                            line = leftover + firstLine;
                            processLine(line, ++lineCount, startTime);
                            leftover = "";
                        }
                    }
                    // 读取当前块剩余行
                    while ((line = reader.readLine()) != null) {
                        // 如果读到当前块最后，先缓存，避免是半行
                        if (reader.ready()) {
                            processLine(line, ++lineCount, startTime);
                        } else {
                            leftover = line;
                        }
                    }
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
                offset += CHUNK_SIZE;
            }
            // 处理最后剩余的内容
            if (!leftover.isEmpty()) {
                processLine(leftover, ++lineCount, startTime);
            }
        } finally {
            s3Client.shutdown();
        }
    }

    private static void processLine(String line, int lineCount, long startTime) throws InterruptedException {
        long stopTime = System.nanoTime();
        double elapsedTimeInSecond = (double) (stopTime - startTime) / 1_000_000_000;
        System.out.println(line);
        System.out.printf("Processing running for : %.2f seconds , at line number ===== %d%n", elapsedTimeInSecond, lineCount);
        Thread.sleep(5000);
    }
}

可选简化方案 #

如果本地磁盘空间足够，可先将整个S3文件下载到本地临时文件，再逐行读取本地文件处理，无需处理分块逻辑，实现更简单，适合非严格流式处理的场景。

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