Java TCP 与 UDP 网络编程详解

表：TCP 与 UDP 协议特性对比

二、Java TCP 网络编程详解

Java 通过 java.net.Socket 和 java.net.ServerSocket 两个核心类，为 TCP 协议提供了面向对象的封装。ServerSocket 用于在服务器端监听和接受客户端的连接请求，而 Socket 则表示一个已经建立的 TCP 连接端点，用于数据的发送和接收。

2.1 TCP 通信的核心 API

• ServerSocket 类：
  • 构造器：ServerSocket(int port) 创建服务器套接字并将其绑定到指定的本地端口。如果端口为 0，则系统会自动分配一个空闲端口。
  • 主要方法：
    • Socket accept()：监听并接受对此套接字的连接。此方法会阻塞，直到一个连接建立起来，然后返回一个新的 Socket 对象，用于与连接的客户端进行通信。
    • void close()：关闭服务器套接字，释放占用的端口资源。
    • void setSoTimeout(int timeout)：设置 accept() 方法的超时时间（毫秒）。如果在超时时间内没有连接到来，会抛出 SocketTimeoutException。
• Socket 类：
  • 构造器：Socket(String host, int port) 创建一个流套接字并将其连接到指定主机上的指定端口号。如果连接失败，会抛出 IOException。
  • 主要方法：
    • InputStream getInputStream()：返回此套接字的输入流，用于从对方接收数据。
    • OutputStream getOutputStream()：返回此套接字的输出流，用于向对方发送数据。
    • void shutdownOutput()：禁用此套接字的输出流。发送一个 TCP FIN 包，表示数据发送完毕，但依然可以接收数据。
    • void shutdownInput()：禁用此套接字的输入流。
    • void close()：关闭此套接字，并关闭相关的输入/输出流。
    • void setSoLinger(boolean on, int linger)：设置当套接字关闭时，是否等待未发送的数据被发送完毕。
    • void setKeepAlive(boolean on)：启用 TCP keep-alive 探测，以防止连接因长时间空闲而被网络中间设备断开。

2.2 实战：构建一个简单的 TCP Echo 服务器与客户端

我们先从最简单的'一发一收'模型开始，理解 TCP 通信的基本流程。

服务器端 (EchoServer)

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 单线程 TCP Echo 服务器
 * 功能：接收客户端消息，并将消息原样返回。
 */
public class EchoServer {
    public static void main(String[] args) {
        int port = 8080; // 服务器监听的端口
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Echo 服务器已启动，监听端口：" + port);
            // 1. 等待客户端连接 (accept 方法会阻塞)
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端已连接：" + clientSocket.getInetAddress().getHostAddress());
            // 2. 获取输入流和输出流
            // 使用 BufferedReader 和 PrintWriter 来方便地读写字符串，并指定字符编码为 UTF-8
            try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream(), "UTF-8"));
                 PrintWriter out = new PrintWriter(new OutputStreamWriter(clientSocket.getOutputStream(), "UTF-8"), true)) {
                // autoFlush 为 true
                String inputLine;
                // 3. 循环读取客户端发送的数据 (readLine 会阻塞，直到读取到换行符或流结束)
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("收到客户端消息：" + inputLine);
                    // 4. 将收到的消息原样返回给客户端，并添加换行符
                    out.println("Echo: " + inputLine);
                }
                System.out.println("客户端连接已关闭。");
            } catch (IOException e) {
                System.err.println("处理客户端通信时出错：" + e.getMessage());
            }
        } catch (IOException e) {
            System.err.println("服务器启动失败：" + e.getMessage());
        }
    }
}

代码解析：

1. 创建 ServerSocket：new ServerSocket(port) 在指定端口上创建服务器套接字。
2. 监听连接：serverSocket.accept() 阻塞等待，直到有客户端连接，并返回一个代表该连接的 Socket 对象。
3. 获取 I/O 流：通过 clientSocket.getInputStream() 和 getOutputStream() 获取与客户端通信的字节流。我们使用 InputStreamReader 和 OutputStreamWriter 将其包装为字符流，并指定 UTF-8 编码，最后用 BufferedReader 和 PrintWriter 获得更高级别的读写功能，如按行读取和写入。
4. 读写数据：使用 in.readLine() 循环读取客户端发送的每一行，并将其打印后，通过 out.println() 原样返回。
5. 资源关闭：当客户端关闭其输出流或连接断开时，readLine() 返回 null，循环结束。我们使用 try-with-resources 语句，确保所有流和 Socket 都会被自动关闭。

客户端 (EchoClient)

import java.io.*;
import java.net.Socket;

/**
 * TCP Echo 客户端
 * 功能：从控制台读取用户输入，发送给服务器，并打印服务器返回的消息。
 */
public class EchoClient {
    public static void main(String[] args) {
        String hostname = "127.0.0.1"; // 服务器地址（本地回环地址）
        int port = 8080; // 服务器端口
        try (Socket socket = new Socket(hostname, port);
             // 用于从控制台读取用户输入
             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
             // 用于从服务器接收数据
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
             // 用于向服务器发送数据
             PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF-8"), true)) {
            System.out.println("已连接到服务器 " + hostname + ":" + port);
            String userInput;
            // 循环读取用户控制台输入
            while ((userInput = consoleReader.readLine()) != null) {
                // 1. 向服务器发送消息
                out.println(userInput);
                // 2. 读取服务器的响应
                String response = in.readLine();
                System.out.println("服务器响应：" + response);
                // 3. 如果用户输入 "bye"，则退出循环
                if ("bye".equalsIgnoreCase(userInput)) {
                    System.out.println("断开连接。");
                    break;
                }
            }
        } catch (IOException e) {
            System.err.println("客户端异常：" + e.getMessage());
        }
    }
}

代码解析：

1. 创建 Socket 连接：new Socket(hostname, port) 尝试连接到指定的服务器地址和端口。此过程即 TCP 三次握手的过程。如果连接失败（如服务器未启动、端口错误），会抛出 IOException。
2. 获取 I/O 流：同样，通过 Socket 获取输入流和输出流，并包装为字符流以便按行读写。
3. 控制台输入：使用另一个 BufferedReader 读取用户在控制台输入的文本。
4. 通信循环：将用户输入的每一行发送给服务器，然后立即读取服务器的响应并打印。
5. 优雅关闭：用户输入'bye'后，退出循环，try-with-resources 会负责关闭所有资源，包括 socket，这将触发 TCP 的四次挥手。

2.3 处理多个客户端：多线程模型

上面的单线程服务器一次只能处理一个客户端。当第一个客户端连接并保持时，accept() 方法不会返回，服务器无法接受其他客户端的连接请求。为了解决这个问题，最直接的方式是为每一个新建立的连接创建一个新的线程来处理。

多线程 Echo 服务器 (MultiThreadedEchoServer)

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadedEchoServer {
    // 使用线程池来管理线程，避免无限制创建线程导致资源耗尽
    private static final ExecutorService threadPool = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        int port = 8080;
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("多线程 Echo 服务器启动，监听端口：" + port);
            while (true) {
                // 主线程持续接受连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("接受新连接：" + clientSocket.getRemoteSocketAddress());
                // 将处理该连接的任务提交给线程池
                threadPool.submit(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

    /**
     * 负责处理单个客户端通信的任务
     */
    static class ClientHandler implements Runnable {
        private final Socket socket;

        public ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            // 处理逻辑与单线程服务器中的处理部分类似
            try (socket;
                 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                 PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF-8"), true)) {
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("[" + Thread.currentThread().getName() + "] 来自 " + socket.getRemoteSocketAddress() + ": " + inputLine);
                    out.println("Echo: " + inputLine);
                }
                System.out.println("客户端 " + socket.getRemoteSocketAddress() + " 断开连接。");
            } catch (IOException e) {
                System.err.println("处理客户端 " + socket.getRemoteSocketAddress() + " 时出错：" + e.getMessage());
            }
        }
    }
}

优化点：

• 线程池：直接为每个连接 new Thread() 在高并发场景下会导致线程创建和销毁的巨大开销，甚至因线程数过多导致系统崩溃。使用 Executors.newCachedThreadPool() 或固定大小的线程池 newFixedThreadPool() 可以有效控制并发线程数量，复用线程，提高系统稳定性。
• 任务分离：主线程专注于 accept() 新连接，处理速度极快。而耗时的 I/O 操作（read()/write()）被交给 ClientHandler 任务在池中线程处理，实现了连接监听和业务处理的解耦。

这种'一个连接一个线程'的模型被称为BIO（Blocking I/O）模型。虽然通过线程池做了优化，但其本质上仍然是阻塞的。当连接数非常大（如数万级别）时，大量的线程处于阻塞等待状态，上下文切换的开销会变得非常巨大，性能急剧下降。这也催生了 NIO 和 AIO 模型的诞生。

三、Java UDP 网络编程详解

UDP 编程与 TCP 有显著不同。在 Java 中，UDP 通信的核心类是 java.net.DatagramSocket（用于发送和接收数据报）和 java.net.DatagramPacket（代表一个数据报本身）。

3.1 UDP 通信的核心 API

• DatagramSocket 类：此类表示一个用于发送和接收数据报包的套接字。
  • 构造器：
    • DatagramSocket()：创建一个数据报套接字并将其绑定到本地主机上任何可用的端口（适用于客户端）。
    • DatagramSocket(int port)：创建一个数据报套接字并将其绑定到本地主机的指定端口（适用于服务器）。
  • 主要方法：
    • void send(DatagramPacket p)：从此套接字发送一个数据报包。
    • void receive(DatagramPacket p)：从此套接字接收一个数据报包。此方法会阻塞，直到收到一个数据报。接收到的数据包内容会填充到 p 中。
    • void close()：关闭此数据报套接字。
• DatagramPacket 类：此类表示一个数据报包。它既用于封装将要发送的数据（需要指定目标地址和端口），也用于存放接收到的数据（需要提供一个空的字节数组缓冲区）。
  • 用于发送的构造器：DatagramPacket(byte[] buf, int length, InetAddress address, int port)。buf 是待发送的数据，length 是数据的长度（通常为 buf.length），address 和 port 是目标主机的地址和端口。
  • 用于接收的构造器：DatagramPacket(byte[] buf, int length)。buf 是用来存放接收数据的字节数组，length 是最大能接收的数据长度。当通过 receive() 方法填充后，可以通过 getData()、getLength()、getAddress()、getPort() 等方法获取数据内容及发送方的信息。

3.2 实战：构建一个简单的 UDP Echo 服务器与客户端

UDP 通信双方的地位是平等的，没有明确的'连接'概念。但习惯上，我们仍将先启动并绑定固定端口、等待接收数据的一方称为服务器。

UDP Echo 服务器 (UdpEchoServer)

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpEchoServer {
    public static void main(String[] args) {
        int port = 9090; // 服务器监听端口
        byte[] buffer = new byte[4096]; // 用于接收数据的缓冲区
        try (DatagramSocket socket = new DatagramSocket(port)) {
            System.out.println("UDP Echo 服务器启动，监听端口：" + port);
            while (true) {
                // 1. 准备一个空的数据报包用于接收
                DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                // 2. 接收客户端的数据报 (receive 会阻塞)
                socket.receive(receivePacket);
                // 3. 从接收到的数据包中提取信息：数据、客户端地址、客户端端口
                String receivedMsg = new String(receivePacket.getData(), 0, receivePacket.getLength(), "UTF-8");
                InetAddress clientAddress = receivePacket.getAddress();
                int clientPort = receivePacket.getPort();
                System.out.printf("收到来自 [%s:%d] 的消息：%s%n", clientAddress.getHostAddress(), clientPort, receivedMsg);
                // 4. 准备响应数据
                String responseMsg = "Echo: " + receivedMsg;
                byte[] responseData = responseMsg.getBytes("UTF-8");
                // 5. 创建一个发送用的数据报包，需要指定目标地址和端口（从接收包中获得）
                DatagramPacket sendPacket = new DatagramPacket(responseData, responseData.length, clientAddress, clientPort);
                // 6. 发送响应
                socket.send(sendPacket);
                System.out.println("响应已发送。");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解析：

1. 创建 DatagramSocket：new DatagramSocket(port) 创建套接字并绑定到指定端口，用于监听和接收数据。
2. 准备接收包：new DatagramPacket(buffer, buffer.length) 创建了一个用于存放接收数据的空数据包。
3. 接收数据：socket.receive(receivePacket) 阻塞等待，直到有数据报到来。数据会被填充到 receivePacket 中。
4. 解析数据：通过 receivePacket.getData()、getLength() 获取实际的数据内容和长度。getAddress() 和 getPort() 则告诉我们数据是谁发来的。
5. 准备并发送响应：创建新的 DatagramPacket，并传入响应数据、数据长度以及从接收包中提取的客户端地址和端口。最后调用 socket.send() 发送出去。

UDP Echo 客户端 (UdpEchoClient)

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UdpEchoClient {
    public static void main(String[] args) {
        String serverHost = "127.0.0.1";
        int serverPort = 9090;
        try (DatagramSocket socket = new DatagramSocket();
             Scanner scanner = new Scanner(System.in)) {
            // 客户端使用系统分配的任意端口
            // 获取服务器地址
            InetAddress serverAddress = InetAddress.getByName(serverHost);
            System.out.println("UDP 客户端启动，目标服务器：" + serverHost + ":" + serverPort);
            while (true) {
                System.out.print("请输入要发送的消息 (输入'bye'退出): ");
                String msg = scanner.nextLine();
                if ("bye".equalsIgnoreCase(msg)) {
                    break;
                }
                // 1. 将消息转换为字节数组
                byte[] sendData = msg.getBytes("UTF-8");
                // 2. 创建发送给服务器的数据报包
                DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
                // 3. 发送数据报
                socket.send(sendPacket);
                System.out.println("消息已发送。");
                // 4. 准备一个接收缓冲区，用于接收服务器响应
                byte[] buffer = new byte[4096];
                DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
                // 5. 接收服务器的响应 (receive 会阻塞，直到收到数据报)
                socket.receive(receivePacket);
                // 6. 解析响应并打印
                String response = new String(receivePacket.getData(), 0, receivePacket.getLength(), "UTF-8");
                System.out.println("收到服务器响应：" + response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

代码解析：

1. 创建 DatagramSocket：使用无参构造器 new DatagramSocket()，让操作系统为我们分配一个临时的源端口。
2. 准备发送包：new DatagramPacket(sendData, sendData.length, serverAddress, serverPort) 创建包含数据、目标地址和端口的数据报包。
3. 发送和接收：通过 send() 发送请求，然后立即 receive() 阻塞等待响应。需要注意的是，UDP 的发送和接收使用的是同一个 DatagramSocket 对象，但端口是相同的。receive() 方法需要有一个独立的、准备就绪的 DatagramPacket 来存放响应数据。

3.3 在 UDP 之上构建可靠性

UDP 协议本身是不可靠的，但在某些特定场景下，我们既需要 UDP 的低延迟特性，又需要一定程度的数据可靠性。这时，我们可以在应用层基于 UDP 构建一个简单的可靠传输协议，例如借鉴 TCP 的思想，实现以下机制：

• 确认与重传（ARQ）：发送方发送每个数据包后，启动一个定时器。接收方收到数据包后，必须回复一个确认（ACK）包。如果发送方在定时器超时前未收到 ACK，则重传该数据包。
• 序列号：在每个数据包中添加序列号，以便接收方对乱序到达的数据包进行排序，并识别重复的数据包。
• 校验和：虽然 UDP 头部已经包含校验和，但应用层可以添加更强大的校验机制，进一步保证数据完整性。

华盛顿大学的 CSE461 课程 Project 1 就设计了一个经典的协议，它要求学生通过 UDP 实现可靠的数据传输：客户端需要发送 num 个 UDP 数据包给服务器，服务器对每个收到的包回复一个 ACK。客户端必须维护一个发送窗口或重传缓冲区，对那些未收到 ACK 的数据包进行超时重传，直到所有数据包都被确认。这个实践完美地展示了如何在 UDP 的不可靠基石上，通过应用层的努力搭建起可靠的通信桥梁。

四、深入 Java NIO：构建高性能网络应用

传统的 BIO（Blocking I/O）模型在处理大量并发连接时显得力不从心。为了解决这个问题，JDK 1.4 引入了 NIO（New I/O / Non-blocking I/O），它提供了完全不同的 I/O 处理模型，允许一个线程管理多个通道（Channel），从而支持高并发、高性能的网络服务。

4.1 NIO 核心组件：Selector, Channel, Buffer

NIO 的三大核心组件协同工作，实现了非阻塞多路复用 I/O。

• Buffer（缓冲区）：在 NIO 中，所有数据的读写都是通过 Buffer 进行的。Buffer 是一个可以读写的内存块。ByteBuffer 是最常用的缓冲区。与 BIO 的流不同，Buffer 是面向块的。核心操作包括 flip()（切换为读模式）、clear()（清空缓冲区，准备写入）、compact()（压缩未读数据，为更多写入腾出空间）等。
• Channel（通道）：通道是双向的，既可以读也可以写，而 BIO 中的流（InputStream/OutputStream）通常是单向的。SocketChannel 用于 TCP 连接，ServerSocketChannel 用于监听 TCP 连接，DatagramChannel 用于 UDP 通信。通道必须配合 Buffer 使用，数据总是从 Channel 读到 Buffer，或从 Buffer 写入 Channel。
• Selector（选择器）：这是 NIO 实现 I/O 多路复用的关键。一个 Selector 可以监听多个 Channel 的事件（如连接事件 OP_ACCEPT、读就绪事件 OP_READ、写就绪事件 OP_WRITE）。应用程序调用 Selector.select() 方法，这个线程会阻塞，直到它所监听的任何一个 Channel 有事件发生。然后，应用程序可以遍历所有发生的事件，并对每个事件进行处理。这样一来，单线程就能高效地管理成千上万个连接。

4.2 实战：基于 NIO 的 Echo 服务器

下面的代码展示了如何使用 NIO 实现一个单线程、非阻塞的 Echo 服务器。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioEchoServer {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        // 1. 打开 ServerSocketChannel
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false); // 设置为非阻塞模式
        serverChannel.socket().bind(new InetSocketAddress(port));
        // 2. 打开 Selector
        Selector selector = Selector.open();
        // 3. 将 ServerSocketChannel 注册到 Selector 上，并指明感兴趣的事件是 OP_ACCEPT
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NIO Echo 服务器启动，监听端口：" + port);
        // 4. 无限循环，等待并处理 I/O 事件
        while (true) {
            // select() 阻塞，直到至少有一个注册的事件发生
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;
            // 获取发生事件的 SelectionKey 集合
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                keyIterator.remove(); // 必须手动移除，防止重复处理
                // 判断事件类型
                if (key.isAcceptable()) {
                    // 有新的连接请求
                    ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = ssc.accept();
                    // 接受连接，得到与客户端通信的 SocketChannel
                    clientChannel.configureBlocking(false); // 设为非阻塞
                    // 将新的 SocketChannel 注册到 Selector 上，关注 OP_READ 事件，并为其绑定一个 ByteBuffer 作为附件
                    clientChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                    System.out.println("接受新连接：" + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 有数据可读
                    SocketChannel clientChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = (ByteBuffer) key.attachment(); // 获取之前绑定的 Buffer
                    int bytesRead = clientChannel.read(buffer); // 从 Channel 读取数据到 Buffer
                    if (bytesRead > 0) {
                        buffer.flip(); // 切换为读模式，准备将数据写回客户端
                        // 这里为了简单，直接将 Buffer 中的数据写回。实际应用中可能涉及拆包粘包处理。
                        clientChannel.write(buffer);
                        buffer.clear(); // 清空 Buffer，准备下一次读取
                    } else if (bytesRead < 0) {
                        // 客户端关闭连接
                        System.out.println("客户端断开连接：" + clientChannel.getRemoteAddress());
                        clientChannel.close();
                        key.cancel(); // 取消该键，Selector 将不再监听此 Channel
                    }
                }
                // 还有 OP_WRITE 事件，用于处理写缓冲区满的情况，本例暂不涉及
            }
        }
    }
}

代码解析：

1. 设置非阻塞：serverChannel.configureBlocking(false) 是关键，它将通道设置为非阻塞模式，使得 accept()、read() 等方法会立即返回（可能返回 0 或特定值），而不会阻塞线程。
2. 注册事件：serverChannel.register(selector, SelectionKey.OP_ACCEPT) 告诉 Selector，我对这个 ServerSocketChannel 的'接受连接'事件感兴趣。
3. 事件循环：selector.select() 是核心，它阻塞并等待事件。一旦有事件发生，我们通过 selectedKeys() 获取所有发生事件的 SelectionKey。
4. 处理事件：通过 key.isAcceptable()、key.isReadable() 等方法判断事件类型，并进行相应处理。
   • 接受连接：对于 OP_ACCEPT，调用 ssc.accept() 获取新的 SocketChannel，并将其也设置为非阻塞模式，注册到同一个 Selector 上，关注其 OP_READ 事件。
   • 读取数据：对于 OP_READ，从 key.attachment() 获取之前绑定的 ByteBuffer，然后调用 clientChannel.read(buffer) 将数据读入 Buffer。读取成功后，将 Buffer 翻转并调用 clientChannel.write(buffer) 将数据回写给客户端。
5. 管理资源：当 read() 返回 -1 时，表示客户端已关闭连接，我们需要关闭对应的 SocketChannel 并取消其 SelectionKey。

4.3 BIO、NIO 与 NIO.2（AIO）对比

随着 Java 的发展，网络 I/O 模型也在不断演进。

• BIO (Blocking I/O)：
  • 模型：一请求一应答，一连接一线程。
  • 特点：编程简单，易于理解。但当连接数激增时，线程数随之增长，导致大量线程上下文切换和内存占用，性能急剧下降。适用于连接数较少且固定的场景。
• NIO (Non-blocking I/O / New I/O)：
  • 模型：基于事件驱动，使用 Selector 实现多路复用，一请求一线程（这里的线程指处理事件的线程，一个线程可管理多个连接）。
  • 特点：在连接数多但每个连接的 I/O 操作频率不高（即'短连接'或'非频繁读写'）的场景下，优势非常明显。它用一个或少量线程处理所有连接的就绪事件，极大地提高了系统伸缩性。但编程复杂度较高，需要处理半包、粘包等问题。
• NIO.2 (AIO, Asynchronous I/O)：
  • 模型：真正的异步非阻塞 I/O。当进行读写操作时，只需要调用 API，传入 CompletionHandler。操作由操作系统内核完成后，会自动回调 CompletionHandler 的方法。
  • 特点：它是真正的异步，不需要通过 Selector 去轮询。编程模型更直观，符合人类思维。但在 Linux 系统上，AIO 的实现底层依然使用 epoll 模拟，性能优势并不总比 NIO 明显。因此，在实际应用中，高性能框架如 Netty，通常选择基于 NIO（通过 epoll）而非 AIO。

表：BIO、NIO、AIO 模型对比

五、网络编程进阶与实战技巧

掌握了基础的 TCP/UDP 和 NIO 编程后，我们还需要了解一些进阶主题，这些是构建稳定、高效、安全网络应用的关键。

5.1 常用 Socket 选项配置

正确配置 Socket 选项可以优化网络应用的性能和健壮性。

• SO_TIMEOUT：设置 InputStream.read() 或 Socket.accept() 等阻塞操作的超时时间。超时后抛出 SocketTimeoutException，允许程序有机会处理其他任务，而不是无限期阻塞。
• SO_REUSEADDR：当服务器关闭后，操作系统通常会保留该端口一段时间（TIME_WAIT 状态），如果立即重启服务器，可能遇到'Address already in use'错误。设置 SO_REUSEADDR 为 true 可以让多个进程（或同一进程重启后）绑定到同一个端口，前提是这些进程使用的地址不同，或者允许端口重用，常用于服务器快速重启。
• SO_LINGER：控制当执行 close() 关闭 Socket 时，如何处理尚未发送的数据。若设置为 false，close() 立即返回，由操作系统在后台完成剩余数据的发送。若设置为 true 和一个超时值（秒），close() 将阻塞，直到数据发送完毕或被确认，或超时发生。这对确保消息完整发送很重要，但需小心处理阻塞问题。
• TCP_NODELAY：对于 TCP 协议，默认启用 Nagle 算法，它会将小的数据包合并成大的数据包再发送，以减少网络开销。但对于需要低延迟的交互式应用（如网络游戏、远程桌面），这会造成明显的延迟。设置 TCP_NODELAY 为 true 可以禁用 Nagle 算法，使得小数据包能立即发送。
• SO_KEEPALIVE：当连接长时间没有数据交换时，启用此选项会促使 TCP 协议栈自动发送探测包以确认对方是否仍然存活。如果探测失败，连接将被关闭。这对于检测'发呆'的连接非常有用。

5.2 编解码与序列化

网络传输的本质是字节流，如何将 Java 对象高效、准确地转换为字节序列（编码/序列化），并在接收方还原（解码/反序列化），是应用层协议设计的核心。

• Java 原生序列化：使用 ObjectInputStream 和 ObjectOutputStream。它简单易用，但存在跨语言支持差、序列化后数据量大、性能低下等严重缺陷，在现代分布式系统中已基本被弃用。
• 文本协议：如 JSON、XML。它们具有良好的可读性和跨语言特性。可以使用 Jackson、Gson、Fastjson 等库轻松实现 Java 对象和 JSON 字符串的转换。缺点是占用空间较大，性能中等。
• 二进制协议：如Protobuf (Google Protocol Buffers)、Thrift (Apache Thrift)、MessagePack、Kryo等。它们通过预定义的数据描述文件（如.proto 文件），生成各语言的编解码代码。优点是序列化后的数据体积小、速度快、跨语言支持好。是高性能 RPC 框架（如 gRPC、Dubbo）的首选。

5.3 粘包与拆包的处理

TCP 是基于字节流的协议，它不保留应用层消息的边界，这就导致了'粘包'和'拆包'问题。发送方发送了两次独立的数据'ABC'和'DEF'，接收方可能一次就收到'ABCDEF'（粘包），也可能分多次收到，比如'AB'和'CDEF'（拆包）。

解决这个问题的关键在于定义清晰的消息边界。常见策略有：

1. 固定长度：每个消息都固定为 N 个字节。不够的用空格或特殊字符填充。这种方式简单但浪费空间。
2. 特殊分隔符：在消息末尾添加一个特殊的字符或字符串作为边界，如换行符\n或\r\n。我们的 Echo 示例就是用的这种方法。它简单，但需要转义内容中的分隔符。
3. 消息头 + 消息体：这是最常用、最灵活的方式。消息分为两部分：一个固定长度的头部和一个变长的消息体。头部中包含了一个字段（如length），明确指示了消息体的长度。接收方先读取固定长度的头部，解析出长度，再读取指定长度的消息体。

例如，华盛顿大学的课程设计中，就要求为每个 UDP/TCP 包定义一个 12 字节的头部，其中包含 payload_len 字段，用于告知对端后续数据的长度，这正是处理消息边界的经典做法。

5.4 安全通信（SSL/TLS）

在许多场景下，网络通信的安全性至关重要，需要保证数据的机密性、完整性和端点身份验证。Java 通过 javax.net.ssl 包提供了对 SSL/TLS 协议的支持。其中核心是 SSLSocket 和 SSLServerSocket，它们的使用方式与普通的 Socket/ServerSocket 非常相似。

实现安全通信的基本步骤：

1. 获取 SSLContext：通过 SSLContext.getInstance("TLS") 获取 TLS 协议的上下文实例。
2. 初始化密钥/信任管理器：
   • 密钥管理器（KeyManager）：管理服务器（或客户端）的私钥和证书，用于向对方证明自己的身份。
   • 信任管理器（TrustManager）：决定是否信任对方提供的证书。例如，客户端会通过信任管理器验证服务器的证书是否由可信的 CA 签发。
3. 创建 SSLSocketFactory：从 SSLContext 中获取 SSLSocketFactory。
4. 创建 SSLSocket/SSLServerSocket：使用工厂创建安全的套接字。之后的数据读写操作与普通 Socket 完全一致，加密/解密过程由底层自动处理。

5.5 性能调优与最佳实践

• 缓冲区大小调整：适当地调整 Socket 的发送和接收缓冲区（SO_SNDBUF, SO_RCVBUF）可以显著影响性能。对于大吞吐量的数据传输，较大的缓冲区可以减少系统调用的次数，提高效率。但过大的缓冲区也可能导致延迟增加。可以根据实际网络带宽和延迟（带宽延迟积）来估算最佳值。
• 连接池：对于频繁建立和关闭连接的场景（如数据库连接、HTTP 请求），使用连接池可以避免三次握手和四次挥手的巨大开销。连接池预先创建并维护一组连接，需要时从池中借用，用后归还，实现了连接的复用。
• 选择正确的 I/O 模型：根据应用的实际并发量和性能要求，审慎选择 BIO、NIO 或基于 NIO 的成熟框架（如 Netty）。对于高并发、高吞吐场景，Netty 几乎是 Java 社区的事实标准。
• 监控与调优：
  • 操作系统层面：使用 netstat、ss 命令监控 TCP 连接状态（ESTABLISHED、TIME_WAIT、CLOSE_WAIT），过多的 TIME_WAIT 或 CLOSE_WAIT 连接可能表示应用有 bug 或配置问题。
  • JVM 层面：使用 JConsole、VisualVM 监控线程数、GC 情况、堆内存使用等。如果发现大量线程处于'BLOCKED'状态，可能遇到了 BIO 模型的瓶颈。
  • 应用层面：记录关键指标，如 QPS（每秒查询数）、平均响应时间、错误率等，以便及时发现性能波动。

六、总结与展望

本文从传输层协议的基本原理出发，全面而深入地探讨了 Java 在网络编程领域的强大能力。

• 我们首先剖析了TCP和UDP的本质区别，理解了面向连接与无连接、可靠与不可靠、字节流与数据报的内在含义。
• 接着，我们通过大量的代码实战，掌握了使用 Socket/ServerSocket 进行TCP 通信的各种模式，从最简单的单线程到实用的多线程模型。同时，也学会了使用 DatagramSocket/DatagramPacket 进行UDP 通信，并探讨了在 UDP 之上构建可靠性的思路。
• 为了应对高并发挑战，我们深入研究了Java NIO的三大组件——Buffer、Channel 和 Selector，并通过 NIO Echo 服务器的例子，展示了如何利用 I/O 多路复用技术让一个线程管理成千上万个连接。我们还对比了 BIO、NIO 和 AIO 模型的优劣，帮助读者在不同场景下做出合理的技术选型。
• 最后，我们探讨了网络编程中不可或缺的进阶主题，包括Socket 选项的配置、编解码与序列化、粘包拆包的解决方案、SSL/TLS 安全通信以及性能调优的最佳实践。