Java网络编程：TCP/UDP套接字通信详解

TCP客户端套接字创建与使用

Socket类基础概念

Socket类的对象代表TCP客户端套接字，用于与TCP服务器套接字进行通信。与服务器端通过accept()方法获取Socket对象不同，客户端需要主动执行三个关键步骤：创建套接字、绑定地址和建立连接。

客户端套接字创建流程

创建TCP客户端套接字主要有两种方式：

// 方式1：直接创建并连接（自动绑定本地可用端口）
Socket socket = new Socket("192.168.1.2", 3456);

// 方式2：分步创建、绑定再连接
Socket socket = new Socket();
socket.bind(new InetSocketAddress("localhost", 14101));
socket.connect(new InetSocketAddress("localhost", 12900));

构造方法允许指定远程IP地址和端口号，未显式绑定时系统会自动绑定到本地主机和可用端口。

数据流操作

建立连接后，通过以下方法获取数据流：

InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();

这些流对象的使用方式与文件I/O操作类似，支持通过缓冲读写器进行高效数据传输。

消息格式约定

客户端与服务器必须预先约定消息格式。示例中采用行文本协议（每行以换行符结尾），这是因为BufferedReader的readLine()方法以换行符作为读取终止标志：

// 必须添加换行符
socketWriter.write(outMsg);
socketWriter.write("\n");
socketWriter.flush();

完整客户端实现示例

以下是回显客户端的核心实现逻辑：

public class TCPEchoClient {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 12900);
             BufferedReader socketReader = new BufferedReader(
                 new InputStreamReader(socket.getInputStream()));
             BufferedWriter socketWriter = new BufferedWriter(
                 new OutputStreamWriter(socket.getOutputStream()))) {
            
            BufferedReader consoleReader = 
                new BufferedReader(new InputStreamReader(System.in));
            
            String promptMsg = "请输入消息(Bye退出):";
            System.out.print(promptMsg);
            
            String outMsg;
            while ((outMsg = consoleReader.readLine()) != null) {
                if (outMsg.equalsIgnoreCase("bye")) break;
                
                // 发送消息（附加换行符）
                socketWriter.write(outMsg + "\n");
                socketWriter.flush();
                
                // 接收服务器响应
                String inMsg = socketReader.readLine();
                System.out.println("服务器响应: " + inMsg);
                System.out.print(promptMsg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

关键注意事项

1. 资源释放：使用try-with-resources确保套接字和流正确关闭
2. 异常处理：捕获IOException处理网络中断等异常情况
3. 连接参数：客户端连接的IP/端口必须与服务器监听地址一致
4. 线程安全：单线程模型适合简单交互，复杂场景需考虑多线程处理

重要提示：关闭后的套接字不可复用，必须创建新实例重新建立连接。通过isClosed()方法可检查套接字状态。

TCP服务端套接字实现原理

ServerSocket类核心功能

ServerSocket类的对象代表TCP服务端套接字，作为被动套接字(passive socket)专门用于接收远程客户端的连接请求。与客户端Socket不同，服务端套接字不直接参与数据传输，而是通过accept()方法创建专用于通信的连接套接字(connection socket)。

服务端绑定操作

创建服务端套接字时，可通过三种构造函数形式完成绑定：

// 基础形式：仅指定端口（等待队列默认50）
ServerSocket serverSocket = new ServerSocket(12900);

// 扩展形式：指定端口和等待队列大小
ServerSocket serverSocket = new ServerSocket(12900, 100);

// 完整形式：指定端口、队列大小和绑定地址
ServerSocket serverSocket = new ServerSocket(
    12900, 
    100, 
    InetAddress.getByName("localhost")
);

也可分步创建未绑定的套接字后显式绑定：

ServerSocket serverSocket = new ServerSocket();
InetSocketAddress endPoint = new InetSocketAddress("localhost", 12900);
serverSocket.bind(endPoint, 100); // 第二个参数为等待队列大小

技术细节：ServerSocket没有独立的listen()方法，bind()方法已包含监听功能，通过waitQueueSize参数控制等待连接队列的容量。

连接接受机制

服务端通过accept()方法进入阻塞等待状态，直到有客户端连接请求到达：

Socket activeSocket = serverSocket.accept();

该方法执行后会产生两个关键变化：

1. 服务端程序中的套接字数量+1（1个被动ServerSocket + 1个主动Socket）
2. 返回的新Socket对象包含远程客户端的IP和端口信息，形成全双工通信通道

多线程处理策略

服务端需要同时处理新连接请求和现有连接的数据传输，常见处理模式包括：

单线程顺序处理（仅适用于极低并发场景）

while(true) {
    Socket activeSocket = serverSocket.accept();
    // 同步处理客户端请求
    handleRequest(activeSocket); 
}

每连接独立线程（简单但存在线程爆炸风险）

while(true) {
    Socket activeSocket = serverSocket.accept();
    new Thread(() -> {
        handleRequest(activeSocket);
    }).start();
}

线程池优化方案（推荐生产环境使用）

ExecutorService pool = Executors.newFixedThreadPool(100);
while(true) {
    Socket activeSocket = serverSocket.accept();
    pool.submit(() -> {
        handleRequest(activeSocket);
    });
}

完整服务端实现示例

以下是基于TCP的Echo服务端核心代码：

public class TCPEchoServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(
                12900, 100, 
                InetAddress.getByName("localhost"));
            
            System.out.println("服务端启动于: " + serverSocket);
            
            while (true) {
                System.out.println("等待客户端连接...");
                final Socket activeSocket = serverSocket.accept();
                
                System.out.println("接收到来自 " + 
                    activeSocket.getRemoteSocketAddress() + " 的连接");
                
                new Thread(() -> {
                    handleClient(activeSocket);
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handleClient(Socket socket) {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream()))) {
            
            String clientMsg;
            while ((clientMsg = reader.readLine()) != null) {
                System.out.println("收到客户端消息: " + clientMsg);
                writer.write(clientMsg + "\n");
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关键实现细节

1. 双工通信：通过getInputStream()和getOutputStream()分别获取输入/输出流
2. 消息边界：使用BufferedReader.readLine()需要确保每条消息以换行符结尾
3. 资源管理 ：
   • 主动关闭连接套接字会同时关闭关联的I/O流
   • 服务端Socket应保持长期运行状态
4. 异常处理 ：
   • 捕获SocketException处理连接中断
   • 使用try-with-resources确保资源释放

性能提示：对于高并发场景，建议使用NIO(New I/O)的ServerSocketChannel替代传统阻塞式ServerSocket。

UDP套接字通信机制

DatagramSocket核心功能

DatagramSocket类实现UDP协议的无连接通信，与TCP套接字不同，UDP套接字不需要建立持久连接。每个数据包（DatagramPacket）都是独立传输的单元，包含完整的目标地址信息。

数据包结构解析

DatagramPacket由以下关键部分组成：

// 创建接收缓冲区（1024字节）
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

• 数据缓冲区(byte[])
• 数据长度(length)
• 源/目标地址(InetAddress)
• 端口号(port)

无连接通信特性

UDP通信具有三大特征：

1. 无连接：无需预先建立连接即可发送数据
2. 不可靠：不保证数据包顺序和可达性
3. 消息边界：数据包保持发送时的原始边界

服务端四步操作

UDP回显服务端仅需四个核心步骤：

// 1. 创建套接字
DatagramSocket socket = new DatagramSocket(15900);

// 2. 准备接收包
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);

// 3. 接收数据
socket.receive(packet); // 阻塞方法

// 4. 回传数据
socket.send(packet); // 自动使用包内源地址

地址信息自动携带

接收到的数据包自动包含发送方地址信息，可通过以下方法获取：

InetAddress clientAddress = packet.getAddress();
int clientPort = packet.getPort();

回传时无需显式设置目标地址，直接使用接收到的包对象即可实现"回声"功能。

完整服务端实现

public class UDPEchoServer {
    public static void main(String[] args) {
        try {
            DatagramSocket socket = new DatagramSocket(15900);
            System.out.println("服务端启动在: " + socket.getLocalSocketAddress());
            
            while (true) {
                DatagramPacket packet = new DatagramPacket(
                    new byte[1024], 1024);
                
                socket.receive(packet);
                System.out.println("收到来自 " + 
                    packet.getAddress() + ":" + 
                    packet.getPort() + " 的数据");
                
                socket.send(packet); // 自动回传
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端实现要点

UDP客户端需要注意：

1. 每次通信都需要完整的目标地址
2. 必须处理数据包截断问题
3. 需要显式设置超时时间

public class UDPEchoClient {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket()) {
            socket.setSoTimeout(5000); // 设置5秒超时
            
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in));
            
            while (true) {
                System.out.print("输入消息(Bye退出): ");
                String msg = reader.readLine();
                if ("bye".equalsIgnoreCase(msg)) break;
                
                // 构造发送包
                DatagramPacket packet = new DatagramPacket(
                    msg.getBytes(), 
                    msg.length(),
                    InetAddress.getByName("localhost"),
                    15900);
                
                socket.send(packet);
                socket.receive(packet); // 接收回显
                
                System.out.println("收到响应: " + 
                    new String(packet.getData(), 0, packet.getLength()));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

关键差异对比

特性	TCP	UDP
连接方式	面向连接	无连接
可靠性	可靠传输	尽力交付
消息边界	字节流	保持数据包边界
性能	较高开销	较低开销
适用场景	文件传输、Web浏览	视频流、DNS查询

注意事项：UDP单次传输数据不宜过大（通常不超过1472字节，考虑MTU限制），大数据需要应用层分片处理。

UDP客户端实现细节

客户端端口自动分配机制

UDP客户端在创建DatagramSocket时若不显式指定端口，系统将自动分配可用端口。这种动态分配机制通过无参构造函数实现：

// 自动分配本地端口
DatagramSocket clientSocket = new DatagramSocket();

与TCP不同，UDP不需要建立连接即可立即发送数据包。通过getLocalPort()方法可获取实际分配的端口号，这在需要向客户端发送响应时尤为重要。

消息长度限制与缓冲区处理

UDP协议要求严格控制数据包大小，通常设置固定长度的缓冲区：

// 设置最大包长度为1024字节
final int MAX_PACKET_SIZE = 1024;
byte[] buffer = new byte[MAX_PACKET_SIZE];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

当发送消息超过缓冲区大小时需要进行截断处理，这在getPacket()工具方法中体现：

if (msgBuffer.length > MAX_PACKET_SIZE) {
    length = MAX_PACKET_SIZE; // 强制截断
}

数据包编址与端口设置方法

每个UDP数据包必须明确指定目标地址和端口，通过DatagramPacket的set方法实现：

// 设置服务器地址和端口
packet.setAddress(InetAddress.getByName("localhost"));
packet.setPort(15900);

值得注意的是，UDPEchoClient中将这些设置封装在getPacket()静态方法中，提高了代码复用性。该方法同时处理了消息缓冲区创建、长度校验和地址配置等操作。

完整客户端工作流程

1. 初始化阶段：

   DatagramSocket socket = new DatagramSocket();
   BufferedReader userInput = new BufferedReader(
       new InputStreamReader(System.in));

2. 消息循环处理：

   while ((msg = userInput.readLine()) != null) {
       if (msg.equalsIgnoreCase("bye")) break;
       
       DatagramPacket packet = getPacket(msg);
       socket.send(packet);
       socket.receive(packet);
       displayPacketDetails(packet);
   }

3. 资源清理：

   finally {
       if (socket != null) socket.close();
   }

通信不可靠性补偿措施

由于UDP的不可靠特性，客户端需要实现以下保护机制：

1. 超时设置（示例代码中未体现但建议添加）：

   socket.setSoTimeout(3000); // 3秒超时

2. 重传逻辑：

   int retries = 3;
   while (retries-- > 0) {
       try {
           socket.send(packet);
           socket.receive(packet);
           break; // 成功接收则退出重试
       } catch (SocketTimeoutException e) {
           // 记录重试日志
       }
   }

3. 数据校验 ：

   可在应用层添加校验和字段，例如：

   String checksum = calculateChecksum(msg);
   String wrappedMsg = checksum + "|" + msg;

数据包解析显示

客户端通过displayPacketDetails()方法解析接收到的数据包，关键信息包括：

String remoteIP = packet.getAddress().getHostAddress();
int remotePort = packet.getPort();
String message = new String(
    packet.getData(), 
    packet.getOffset(), 
    packet.getLength());

该方法标准化了数据包信息的输出格式，便于调试和日志记录，输出示例：

[Server at IP=127.0.0.1:15900]: Hello World

关键实践建议：生产环境中应考虑使用单独的日志组件（如Log4j）替代System.out，并添加消息序列号以便追踪丢包情况。对于需要可靠传输的场景，建议在应用层实现ACK确认机制或直接改用TCP协议。

网络通信实践对比

TCP与UDP协议特性对比

TCP提供面向连接的可靠传输，通过三次握手建立连接，确保数据顺序和完整性，适合文件传输等场景。UDP采用无连接方式，不保证数据可达性，但具有更低的开销和更快的传输速度，适用于实时视频流和DNS查询等场景。

消息边界处理的差异

TCP作为字节流协议不保留消息边界，需要应用层处理消息分割（如添加换行符）：

// TCP需要显式添加消息分隔符
socketWriter.write(message + "\n");

UDP则天然保持数据包边界，每个DatagramPacket都是独立单元：

// UDP自动维护消息边界
socket.receive(packet); // 接收完整数据包

连接建立过程的区别

TCP需要显式的连接建立过程：

// 客户端连接过程
Socket socket = new Socket();
socket.connect(endpoint);

// 服务端接受连接
ServerSocket serverSocket = new ServerSocket(port);
Socket activeSocket = serverSocket.accept();

UDP无需连接即可直接通信：

// UDP直接发送数据包
DatagramSocket socket = new DatagramSocket();
socket.send(packet);

性能与可靠性权衡选择

考量维度	TCP优势场景	UDP优势场景
可靠性	金融交易数据	实时视频会议
延迟敏感性	容忍百毫秒延迟	要求毫秒级响应
带宽效率	大数据量传输	小数据包高频发送

典型应用场景分析

1. 必须使用TCP的场景：

   • Web服务(HTTP/HTTPS)
   • 电子邮件(SMTP)
   • 数据库连接

2. 推荐使用UDP的场景：

   • 实时多媒体传输(RTP)
   • 网络游戏状态更新
   • IoT设备状态上报

混合方案建议：现代应用常采用混合模式，如QUIC协议在UDP上实现可靠传输，兼顾速度和可靠性。关键业务数据建议使用TCP，辅助性数据可考虑UDP。

总结

本章完整演示了TCP/UDP套接字编程的核心实现流程，通过Echo服务案例对比展示了两种传输协议的本质差异。关键要点包括：

1. TCP流式传输必须严格处理：

   • 通过Socket/ServerSocket建立可靠连接
   • 使用getInputStream()/getOutputStream()进行双工通信
   • 消息边界需显式约定（如换行符分隔）

2. UDP数据报特性体现为：

   • DatagramSocket直接发送/接收独立数据包
   • 每个DatagramPacket自带地址信息
   • 需自行处理丢包和乱序问题

3. 服务端核心模式：

   // TCP多线程服务端模板
   while(true) {
       Socket clientSocket = serverSocket.accept();
       new Thread(() -> handleClient(clientSocket)).start();
   }
   
   // UDP无状态处理模板
   while(true) {
       socket.receive(packet);
       socket.send(packet); // 自动回传
   }

4. 生产环境必备：

   • TCP服务端需采用线程池（如ThreadPoolExecutor）
   • UDP应添加超时控制（setSoTimeout()）
   • 两种协议都需要严格的消息格式约定

5. 协议选型原则：

   • 可靠性优先选TCP
   • 低延迟优先选UDP
   • 混合场景可考虑在UDP上层实现可靠传输机制

重要实践提示：实际开发中应使用NIO（SocketChannel/DatagramChannel）处理高并发场景，同时建议结合Wireshark等工具进行网络包分析。