Java Socket 传输大文件指南

在Java中使用Socket传输大文件需要考虑几个关键问题：内存管理、网络效率、错误处理和进度监控，下面我将提供一个完整的解决方案。

基本实现方案

服务器端代码

import java.io.*;
import java.net.*;
public class FileServer {
    public static void main(String[] args) {
        int port = 12345;
        String filePath = "largefile.zip"; // 要传输的文件路径
        try (ServerSocket serverSocket = new ServerSocket(port);
             Socket clientSocket = serverSocket.accept();
             FileInputStream fileInputStream = new FileInputStream(filePath);
             OutputStream outputStream = clientSocket.getOutputStream()) {
            System.out.println("客户端已连接，开始传输文件...");
            byte[] buffer = new byte[4096]; // 4KB缓冲区
            int bytesRead;
            long totalBytes = fileInputStream.available();
            long bytesTransferred = 0;
            while ((bytesRead = fileInputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
                bytesTransferred += bytesRead;
                // 打印传输进度
                double progress = (bytesTransferred * 100.0) / totalBytes;
                System.out.printf("传输进度: %.2f%%%n", progress);
            }
            System.out.println("文件传输完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码

import java.io.*;
import java.net.*;
public class FileClient {
    public static void main(String[] args) {
        String serverAddress = "localhost";
        int port = 12345;
        String savePath = "received_file.zip"; // 保存路径
        try (Socket socket = new Socket(serverAddress, port);
             InputStream inputStream = socket.getInputStream();
             FileOutputStream fileOutputStream = new FileOutputStream(savePath)) {
            System.out.println("已连接到服务器，开始接收文件...");
            byte[] buffer = new byte[4096]; // 4KB缓冲区
            int bytesRead;
            long totalBytes = 0;
            // 首先获取文件大小（可选）
            DataInputStream dataInputStream = new DataInputStream(inputStream);
            totalBytes = dataInputStream.readLong();
            long bytesTransferred = 0;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                fileOutputStream.write(buffer, 0, bytesRead);
                bytesTransferred += bytesRead;
                // 打印接收进度
                double progress = (bytesTransferred * 100.0) / totalBytes;
                System.out.printf("接收进度: %.2f%%%n", progress);
            }
            System.out.println("文件接收完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

优化方案

使用NIO提高性能

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;
public class NioFileServer {
    public static void main(String[] args) {
        int port = 12345;
        String filePath = "largefile.zip";
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open();
             SocketChannel clientChannel = serverChannel.bind(new InetSocketAddress(port)).accept();
             FileChannel fileChannel = FileChannel.open(Paths.get(filePath), StandardOpenOption.READ)) {
            System.out.println("客户端已连接，开始传输文件...");
            long fileSize = fileChannel.size();
            ByteBuffer buffer = ByteBuffer.allocateDirect(4096); // 直接缓冲区
            long totalBytesTransferred = 0;
            while (totalBytesTransferred < fileSize) {
                buffer.clear();
                int bytesRead = fileChannel.read(buffer);
                if (bytesRead == -1) break;
                buffer.flip();
                while (buffer.hasRemaining()) {
                    totalBytesTransferred += clientChannel.write(buffer);
                }
                double progress = (totalBytesTransferred * 100.0) / fileSize;
                System.out.printf("传输进度: %.2f%%%n", progress);
            }
            System.out.println("文件传输完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

分块传输与校验

import java.io.*;
import java.net.*;
import java.security.*;
public class SecureFileTransfer {
    public static void main(String[] args) {
        // 服务器端和客户端实现类似，但增加了MD5校验
        // 这里只展示服务器端关键部分
        try (ServerSocket serverSocket = new ServerSocket(12345);
             Socket clientSocket = serverSocket.accept();
             FileInputStream fileInputStream = new FileInputStream("largefile.zip");
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 计算文件MD5
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] fileBuffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = fileInputStream.read(fileBuffer)) != -1) {
                md.update(fileBuffer, 0, bytesRead);
            }
            byte[] fileDigest = md.digest();
            // 重置流位置
            fileInputStream.getChannel().position(0);
            // 先发送MD5
            outputStream.write(fileDigest);
            // 然后发送文件内容
            byte[] transferBuffer = new byte[4096];
            long totalBytes = fileInputStream.available();
            long bytesTransferred = 0;
            while ((bytesRead = fileInputStream.read(transferBuffer)) != -1) {
                outputStream.write(transferBuffer, 0, bytesRead);
                bytesTransferred += bytesRead;
                double progress = (bytesTransferred * 100.0) / totalBytes;
                System.out.printf("传输进度: %.2f%%%n", progress);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

关键注意事项

1. 缓冲区大小：根据网络条件调整缓冲区大小，通常4KB-64KB之间效果较好
2. 内存管理：大文件传输时避免一次性加载整个文件到内存
3. 错误处理：实现重传机制和超时处理
4. 进度监控：定期报告传输进度
5. 网络优化：考虑使用TCP_NODELAY选项减少延迟
6. 安全性：对于敏感文件，考虑加密传输
7. 并发处理：如果需要同时处理多个客户端，使用线程池

高级优化建议

1. 使用零拷贝技术：通过FileChannel.transferTo()方法减少数据拷贝
2. 压缩传输：在传输前压缩文件，减少网络负载
3. 断点续传：记录已传输的字节数，支持从中断处继续传输
4. 流量控制：实现滑动窗口等流量控制机制
5. 多线程传输：将大文件分块，使用多线程并行传输

方案可以根据实际需求进行组合和调整,以达到最佳的性能和可靠性。