探索Java网络编程模型：Socket、UDP、NIO和Netty的全景视角

Java Socket 编程
--------------

Java 的 Socket API 是基于 TCP/IP 协议栈的封装，它包含了服务器端和客户端两部分。服务器端主要包括以下步骤： - 创建 ServerSocket 对象，绑定监听端口； - 调用 ServerSocket 的 accept()方法监听客户端连接请求； - 当有客户端请求连接时，accept()方法会返回一个 Socket 对象，用于与客户端进行通信； - 通过输入输出流进行数据传输。 客户端主要包括以下步骤： - 创建 Socket 对象，指定服务器的地址和端口； - 通过输入输出流进行数据传输。 Java Socket 编程是基于 TCP/IP 协议的网络编程，主要用于实现网络通信。Socket 编程可以用于实现客户端与服务器之间的通信，包括数据传输、命令执行和文件传输等。在 Java 中，Socket 编程可以通过 java.net 包中的 Socket 和 ServerSocket 类实现。 1. Socket 类 Socket 类表示客户端与服务器之间的一个连接。它提供了实现数据传输的各种方法，包括读取和写入数据、关闭连接等。 创建一个 Socket 对象的方式如下：```
 Socket socket = new Socket(host, port); 
```其中，host 表示服务器主机的 IP 地址或主机名，port 表示服务器开放的端口号。 2. ServerSocket 类 ServerSocket 类表示服务器端的套接字。它用于监听来自客户端的连接请求，并在连接请求到来时创建一个新的 Socket 对象来与客户端进行通信。 创建一个 ServerSocket 对象的方式如下：```
 ServerSocket serverSocket = new ServerSocket(port); 
```其中，port 表示服务器开放的端口号。 3. 实现客户端与服务器的通信 客户端与服务器之间的通信可以通过 Socket 类的 InputStream 和 OutputStream 实现。当客户端与服务器建立连接后，可以通过 Socket 对象获取相应的输入流和输出流，从而进行数据的读取和写入。 客户端的代码示例：```
 Socket socket = new Socket(host, port);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("Hello, Server!".getBytes());

InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = inputStream.read(buffer);
String message = new String(buffer, 0, len);
System.out.println("Message from server: " + message);

socket.close(); 
```服务器端的代码示例：```
 ServerSocket serverSocket = new ServerSocket(port);
Socket socket = serverSocket.accept();

InputStream inputStream = socket.getInputStream();
byte[] buffer = new byte[1024];
int len = inputStream.read(buffer);
String message = new String(buffer, 0, len);
System.out.println("Message from client: " + message);

OutputStream outputStream = socket.getOutputStream();
outputStream.write("Hello, Client!".getBytes());

socket.close();
serverSocket.close(); 
```其中，host 表示服务器主机的 IP 地址或主机名，port 表示服务器开放的端口号。 4. 其他常用方法 除了上述方法外，Socket 类还提供了一些常用的方法，包括： - getInputStream()：获取 Socket 的输入流。 - getOutputStream()：获取 Socket 的输出流。 - setSoTimeout(int timeout)：设置 Socket 的读取超时时间。 - setKeepAlive(boolean on)：设置 Socket 是否开启保持活动状态。 - setTcpNoDelay(boolean on)：设置 Socket 是否开启无延迟模式。 ServerSocket 类也提供了一些常用的方法，包括： - accept()：等待客户端连接并返回一个 Socket 对象。 - close()：关闭 ServerSocket 对象。 总的来说，Java Socket 编程是实现网络通信的一种简单而有效的方式。它提供了方便的方法和工具，可以轻松地实现客户端与服务器之间的通信 **案例：** 下面是一个简单的 Java Socket 编程的 Demo，实现了客户端向服务器发送数据，服务器接收并打印数据的功能： 客户端代码：```
 import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

public class SocketClientDemo {
    public static void main(String[] args) {
        String serverHost = "localhost"; // 服务器地址
        int serverPort = 8888; // 服务器端口号
        Socket socket = null;
        OutputStream out = null;
        try {
            // 创建 Socket 对象
            socket = new Socket(serverHost, serverPort);
            // 获取输出流
            out = socket.getOutputStream();
            // 向服务器发送数据
            String message = "Hello World!";
            out.write(message.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭输出流和 Socket
                out.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
} 
```服务器端代码：```
 import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServerDemo {
    public static void main(String[] args) {
        int serverPort = 8888; // 服务器端口号
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        try {
            // 创建 ServerSocket 对象
            serverSocket = new ServerSocket(serverPort);
            // 等待客户端连接
            socket = serverSocket.accept();
            // 获取输入流
            in = socket.getInputStream();
            // 读取客户端发送的数据
            byte[] buffer = new byte[1024];
            int len = in.read(buffer);
            String message = new String(buffer, 0, len);
            System.out.println("Received message from client: " + message);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭输入流、Socket 和 ServerSocket
                in.close();
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
} 
```以上 Demo 展示了 Socket 编程的基本流程，包括客户端创建 Socket 对象并向服务器发送数据，服务器创建 ServerSocket 对象并等待客户端连接，客户端和服务器之间通过输入输出流进行数据传输。

Java UDP 编程
-----------

Java UDP 编程也是基于 Socket API 实现的。服务器端和客户端的实现与 TCP 编程基本一致，只是使用 DatagramSocket 和 DatagramPacket 对象进行数据传输。 UDP 是一种无连接、不可靠、面向数据报的传输协议，它与 TCP 不同，UDP 只提供数据报服务，不提供面向连接的服务。在 Java 中，UDP 编程可以使用 java.net 包中的 DatagramSocket 和 DatagramPacket 类。 下面是 UDP 编程的基本流程： 1. 创建 DatagramSocket 对象，指定端口号。```
 DatagramSocket socket = new DatagramSocket(8888); 
```2\. 创建 DatagramPacket 对象，包含发送的数据、发送的数据长度、目的 IP 地址和端口号。```
 String msg = "Hello, UDP!";
byte[] buf = msg.getBytes();
InetAddress address = InetAddress.getByName("192.168.1.100");
int port = 9999;
DatagramPacket packet = new DatagramPacket(buf, buf.length, address, port); 
```3\. 使用 DatagramSocket 的 send 方法发送数据报。 socket.send(packet); 4. 创建 DatagramPacket 对象，接收数据报。```
 byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet); 
```5\. 解析接收到的数据。```
 String msg = new String(packet.getData(), 0, packet.getLength()); 
```6\. 关闭 DatagramSocket 对象。```
 socket.close(); 
```下面是一个简单的 UDP 编程示例，它实现了向指定 IP 地址和端口号发送数据报，并接收数据报的功能：```
 import java.net.*;

public class UDPServer {
    public static void main(String[] args) {
        try {
            // 创建 DatagramSocket 对象，指定端口号
            DatagramSocket socket = new DatagramSocket(8888);

            // 创建发送的数据报
            String msg = "Hello, UDP!";
            byte[] buf = msg.getBytes();
            InetAddress address = InetAddress.getByName("192.168.1.100");
            int port = 9999;
            DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, address, port);

            // 发送数据报
            socket.send(sendPacket);

            // 创建接收的数据报
            byte[] recvBuf = new byte[1024];
            DatagramPacket recvPacket = new DatagramPacket(recvBuf, recvBuf.length);

            // 接收数据报
            socket.receive(recvPacket);

            // 解析接收到的数据
            String recvMsg = new String(recvPacket.getData(), 0, recvPacket.getLength());
            System.out.println("Received message: " + recvMsg);

            // 关闭 DatagramSocket 对象
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} 
```上面的示例中，我们创建了一个 DatagramSocket 对象并指定了端口号，然后创建了一个发送的数据报，将它发送到指定的 IP 地址和端口号。接着，我们创建了一个接收的数据报，并使用 DatagramSocket 的 receive 方法接收数据报。最后，我们解析接收到的数据，并关闭了 DatagramSocket 对象。 **案例：** 以下是一个简单的 Java UDP 编程的示例代码：```
 import java.net.*;

public class UDPClientServerDemo {
    public static void main(String[] args) throws Exception {
        // 客户端代码
        DatagramSocket clientSocket = new DatagramSocket();
        String message = "Hello, server!";
        InetAddress serverAddress = InetAddress.getByName("localhost");
        int serverPort = 9876;
        byte[] sendData = message.getBytes();
        DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, serverPort);
        clientSocket.send(sendPacket);

        // 服务器代码
        DatagramSocket serverSocket = new DatagramSocket(9876);
        byte[] receiveData = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
        serverSocket.receive(receivePacket);
        String receivedMessage = new String(receivePacket.getData(), 0, receivePacket.getLength());
        System.out.println("Message from client: " + receivedMessage);
        serverSocket.close();
    }
} 
```该示例包含了客户端和服务器端两个部分。在客户端中，首先创建一个 DatagramSocket 对象，并准备发送给服务器的消息。然后，使用 InetAddress 类获取服务器的 IP 地址，并指定服务器的端口号。接下来，将消息转换为字节数组，并使用 DatagramPacket 将其打包。最后，使用 DatagramSocket 的 send 方法将消息发送给服务器。 在服务器端，首先创建一个 DatagramSocket 对象，并指定服务器要监听的端口号。然后，创建一个字节数组用于存储接收到的消息，使用 DatagramPacket 将其打包，并使用 DatagramSocket 的 receive 方法等待客户端发送的消息。一旦接收到消息，将其转换为字符串，并输出到控制台。最后，关闭 DatagramSocket 对象。 需要注意的是，UDP 是无连接协议，因此客户端和服务器之间并不需要建立连接，而是直接通过 DatagramPacket 进行消息的发送和接收。由于 UDP 不保证消息的可靠性和顺序性，因此需要开发人员自行处理丢失消息和乱序消息等问题。

Java NIO
--------

Java NIO（New I/O）是 Java 的一种新的 IO（输入/输出）模型，它提供了与传统的 Java IO（输入/输出）不同的、更高效的 IO 操作方式。相比 Java IO，Java NIO 的主要优点是它可以支持非阻塞 IO 操作，使得单个线程可以管理多个并发连接，大大提高了系统的性能和吞吐量。 Java NIO 中的主要组件包括：缓冲区（Buffer）、通道（Channel）、选择器（Selector）和操作标记（InterestOps）。缓冲区用于在通道和应用程序之间传输数据，通道用于连接数据源和数据目标，选择器用于管理通道的 IO 操作，操作标记用于指示选择器感兴趣的 IO 事件。 使用 Java NIO 进行网络编程的基本步骤包括： 1.打开一个通道（Channel）：使用\`java.nio.channels.Channel\`类的实现类来打开一个通道，如：\`SocketChannel\`或\`ServerSocketChannel\`。 2.绑定通道到本地地址：使用\`bind()\`方法将通道绑定到本地地址上。 3.连接到远程服务器：如果是客户端程序，则使用\`connect()\`方法连接到远程服务器。 4.创建缓冲区（Buffer）：使用\`java.nio.Buffer\`的实现类来创建缓冲区。 5.写入数据到缓冲区：使用缓冲区的\`put()\`方法写入数据。 6.从缓冲区读取数据：使用缓冲区的\`get()\`方法从缓冲区读取数据。 7.注册一个选择器（Selector）：使用\`java.nio.channels.Selector\`类来创建选择器。 8.将通道注册到选择器上：使用\`register()\`方法将通道注册到选择器上，并指定需要监听的 IO 事件。 9.处理选择器上的 IO 事件：使用选择器的\`select()\`方法来等待 IO 事件，当有事件发生时，使用选择器的\`selectedKeys()\`方法来获取选择器上的所有 IO 事件，并处理这些事件。 10.关闭通道和选择器：使用\`close()\`方法关闭通道和选择器。 **案例：** 客户端```
 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.SocketChannel;
import java.time.LocalDateTime;
import java.util.Iterator;
import java.util.Set;

public class NIOClient {
    private Selector selector;
    private ByteBuffer buffer = ByteBuffer.allocate(1024);

    public static void main(String[] args) throws IOException {
        NIOClient client = new NIOClient();
        client.initClient("localhost", 8888);
        client.start();
    }

    public void initClient(String ip, int port) throws IOException {
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        this.selector = Selector.open();
        channel.connect(new InetSocketAddress(ip, port));
        channel.register(selector, SelectionKey.OP_CONNECT);
    }

    public void start() throws IOException {
        while (true) {
            selector.select();
            Set keys = selector.selectedKeys();
            Iterator iterator = keys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();
                handleKey(key);
            }
        }
    }

    private void handleKey(SelectionKey key) throws IOException {
        if (key.isConnectable()) {
            SocketChannel channel = (SocketChannel) key.channel();
            if (channel.finishConnect()) {
                channel.configureBlocking(false);
                channel.register(selector, SelectionKey.OP_READ);
                channel.write(ByteBuffer.wrap("Hello Server".getBytes()));
            }
        } else if (key.isReadable()) {
            SocketChannel channel = (SocketChannel) key.channel();
            buffer.clear();
            int len = channel.read(buffer);
            if (len > 0) {
                buffer.flip();
                String message = new String(buffer.array(), 0, len);
                System.out.println("Received message: n"
                        + "ClientTime:" + LocalDateTime.now() + "n" +
                        message);
            }
        }
    }
} 
```服务端```
 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.time.LocalDateTime;
import java.util.Set;

public class NIOServer {
    private Selector selector;
    private ByteBuffer buffer = ByteBuffer.allocate(1024);

    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8888);
        server.start();
    }

    public void initServer(int port) throws IOException {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(port));
        this.selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("Server started on port " + port);
    }

    public void start() throws IOException {
        while (true) {
            selector.select();
            Set keys = selector.selectedKeys();
            for (SelectionKey key : keys) {
                handleKey(key);
            }
            keys.clear();
        }
    }

    private void handleKey(SelectionKey key) throws IOException {
        if (key.isAcceptable()) {
            ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
            System.out.println(LocalDateTime.now() + " Accepted connection from: " + clientChannel.getRemoteAddress());
        } else if (key.isReadable()) {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            buffer.clear();
            int len = clientChannel.read(buffer);
            if (len > 0) {
                buffer.flip();
                String message = new String(buffer.array(), 0, len);
                System.out.println(LocalDateTime.now() + " Received message from " + clientChannel.getRemoteAddress() + ": " + message);

                // Echo the message back to the client
                clientChannel.write(ByteBuffer.wrap(("ServerTime:" + LocalDateTime.now() + "n" + message).getBytes()));
            }
        }
    }
}