网络编程：自定义协议设计&IO多路复用
自定义协议设计步骤详解
设计一个好的自定义网络协议，通常遵循以下两个核心步骤：
一、依据需求明确所需传输的内容
强调分析应用需求，定义清楚需要交换的数据字段、类型和约束。例如聊天应用需要发送者ID、消息内容、时间戳等。
具体化需求
- 聊天应用： 可能需要传输：发送者ID、接收者ID、消息类型（文本、图片、文件）、时间戳、消息具体内容、消息序列号（用于确认或排序）等
- 游戏应用： 可能需要传输：玩家ID、玩家位置坐标（x, y, z）、玩家动作（移动、跳跃、攻击）、游戏状态更新、同步指令等
- 物联网(IoT)应用： 可能需要传输：设备ID、传感器类型、时间戳、采集到的数据值（温度、湿度、压力）、设备状态码等
二、约定信息组织格式
确定了要传输什么内容之后，下一步就是决定如何将这些内容组织成字节流进行传输。以下是几种常见格式及其优缺点分析，并直接展示该格式的示例：
-
行文本格式 (Line Text Format)
- 描述： 用换行符（
\n）分隔消息或字段。 - 优点： 极其简单，人类可读，轻量级。
- 缺点： 结构能力弱，边界处理麻烦，解析效率低，不适合二进制。
- 格式示例（模拟登录请求）：
LOGIN user123 password
（注意：每一行末尾通常有一个不可见的换行符
\n） - 描述： 用换行符（
-
HTML (HyperText Markup Language)
- 描述： 主要用于网页的标记语言。
- 优点： 标准化，浏览器原生支持，表现力强（用于渲染）。
- 缺点： 极其冗余，非数据交换设计，解析复杂。强烈不推荐作为通用的程序间通信协议。
- 格式示例（包含用户信息的片段）：
<html> <body> <h1>用户信息</h1> <p>用户名: <b>user123</b></p> <p>状态: <span style='color:green;'>Online</span></p> </body> </html>
-
XML (Extensible Markup Language)
- 描述： 使用标签组织数据，侧重结构和含义。
- 优点： 标准化，自描述性，支持复杂结构，有Schema支持，跨平台性好，相对可读。
- 缺点： 冗余，解析性能相对较低，略显笨重。
- 格式示例（用户信息）：
<User> <id>1001</id> <username>user123</username> <status>Active</status> </User>
-
JSON (JavaScript Object Notation)
- 描述： 轻量级数据交换格式。
- 优点： 轻量简洁，人类可读，易于解析/生成，数据结构映射好。
- 缺点： 文本格式效率不如二进制，不支持注释，二进制数据需Base64，类型信息有限，无内建Schema。
- 格式示例（用户信息）：
{ "id": 1001, "username": "user123", "status": "Active" }
-
Protocol Buffers (Protobuf)
- 描述： Google 开发的高效二进制序列化方法。
- 优点： 极高效率，强类型与Schema，跨语言，兼容性好，应用广泛。
- 缺点： 非人类可读，需要预定义
.proto文件和编译步骤，灵活性相对较低。 - 格式示例（定义文件
.proto）： - 注意： Protobuf 的传输格式是二进制，无法直接展示。以下是定义其结构的
.proto文件示例。syntax = "proto3"; // 指定 proto3 语法 package example.protocol; // 包名 message User { int64 id = 1; // 字段编号从 1 开始 string username = 2; string status = 3; }
（实际传输的是根据这个定义序列化后的紧凑二进制数据）
-
自定义二进制格式（示例：长度前缀 + 简单字段）
- 描述： 完全自定义字节如何排列。
- 优点： 极致的控制权，可能达到最佳性能/体积。
- 缺点： 设计、实现、维护成本最高，易出错，跨语言支持难。
- 格式示例（结构描述）：
- 注意： 二进制格式无法直接文本展示，以下是其结构描述。
+-----------------+-----------------+------------------+-----------------+ | 载荷长度 (4 字节) | 用户ID (8 字节) | 用户名长度(1字节) | 用户名 (可变长度) | +-----------------+-----------------+------------------+-----------------+ - 载荷长度： 后面三部分（用户ID+用户名长度+用户名）的总字节数，用4字节整数表示。
- 用户ID： 用8字节长整型 (long) 表示。
- 用户名长度： 用1字节表示后面用户名字段的字节数 (0-255)。
- 用户名： 使用UTF-8编码的用户名实际字节。
（实际传输的是按照这个结构排列的一串字节数据）
如何选择
（这部分与之前相同，强调根据可读性、性能、体积、易用性、场景需求等权衡选择。）
- 人类可读、调试方便、Web交互多？ -> JSON
- 高性能、小体积、跨语言、强类型？ -> Protobuf 或其他二进制方案
- 与旧系统交互或需严格Schema？ -> XML
- 协议极简单？ -> 行文本格式
- 避免使用HTML
二、用大白话聊聊IO多路复用的特点
想象一下，你就是那个Java代码里的主线程（main 方法里的那个 while(true) 循环），而你要服务的网络连接（比如好多用户同时访问你的服务器）就像是图片里那些不同的摊位（蛋炒饭、油泼面、煎饼果子）。
传统方式的麻烦
- 阻塞IO (BIO)： 就像你死守在蛋炒饭摊位前，老板没做好你就一直等，啥也不干了。放到Java里，就是一个线程对应一个连接，如果那个连接没数据来，线程就卡在那儿（
read()方法阻塞），纯属浪费资源。连接一多，线程就爆炸了。 - 非阻塞IO (NIO 但没用 Selector)： 就像你一会儿跑去问蛋炒饭好了没，一会儿又跑去问油泼面好了没，一会儿又跑去问煎饼果子… 你是不等了，但你累啊！不停地跑腿问（轮询），大部分时候都是白问，CPU空转，效率还是很低。
IO多路复用 (Selector) 的聪明之处
-
登记报备 (register)：
- 你先去各个摊位（
Channel）下单，并且告诉老板（操作系统内核）：“老板，我点了这个，做好了或者有啥情况了喊我一声哈！” - 对应Java代码：
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);就是告诉Selector：“听着点儿，要是有新顾客来（OP_ACCEPT），通知我。”clientChannel.register(selector, SelectionKey.OP_READ);就是告诉Selector：“这个顾客（clientChannel）要是说话了（OP_READ），通知我。”
- 特点1：一个线程管多个事儿。 你看，自始至终，主要就是你这一个线程在跑腿和监听。不需要为每个摊位（连接）都配一个专门的你（线程）！这就是资源高效，省人力（线程）！
- 你先去各个摊位（
-
集中等待 (select)：
- 你找个中间的位置坐下，竖起耳朵听。哪个摊位老板喊你了，你再去处理。没人喊你，你就安心等着（但不是傻等，是在高效地等“任何一个”事件）。
- 对应Java代码：
selector.select();这句就是你的“竖起耳朵听”的动作。它会暂停（阻塞），直到至少有一个你关心的摊位（Channel）发生了你关心的事件（比如OP_ACCEPT或OP_READ）。一旦有事发生，它就立刻返回，告诉你“有人喊你啦！” - 特点2：事件驱动。 你不再是无头苍蝇一样到处问，而是等着别人通知你。只有真正有事（数据来了、连接来了）的时候，你才需要干活。这大大减少了无效的操作。
-
精准处理 (遍历 selectedKeys)：
select()告诉你有人喊你了，selector.selectedKeys()就告诉你具体是哪些摊位老板在喊你（哪些Channel准备好了）。- 你遍历这个列表（
while (keyIterator.hasNext())），看看是新顾客来了（key.isAcceptable()）还是老顾客要说话（key.isReadable()）。 handleAccept()就是去接待新顾客，handleRead()就是去听老顾客说话并回应。- 特点3：非阻塞配合。 注意，无论是
ServerSocketChannel还是SocketChannel，我们都设置了configureBlocking(false)。这意味着，当你去accept()或者read()的时候，这些操作本身不会卡住你太久。因为Selector已经告诉你它们“就绪”了，你去操作大概率能立刻拿到结果（新连接或数据）。即使因为某些原因数据又没了（比如ET模式下没读完），这个非阻塞调用也会快速返回，不会让你这个唯一的线程卡死在某个连接上。
-
事后清理 (keyIterator.remove())：
- 这个非常重要！就像你听完一个老板的喊话，处理完他的事，你得在心里把这个“已处理”标记一下，不然下次你竖耳朵听的时候，可能还会把这个已经处理过的事又当成新事情。
keyIterator.remove()就是这个标记动作，防止重复处理同一个事件。
- 这个非常重要！就像你听完一个老板的喊话，处理完他的事，你得在心里把这个“已处理”标记一下，不然下次你竖耳朵听的时候，可能还会把这个已经处理过的事又当成新事情。
总结一下IO多路复用的核心特性
- 省人 (线程)： 一个或很少几个线程就能管一大堆连接，不像BIO那样一个连接就得配一个线程，大大节省了服务器资源。
- 效率高 (事件驱动)： 不用傻等，也不用瞎忙活轮询，只在真正有事发生时才去处理，CPU利用率高。
- 反应快 (非阻塞配合)：
Selector负责告诉你什么时候可以干活，非阻塞的Channel保证你真去干活的时候不会轻易被卡住。
所以，IO多路复用（在Java里主要靠 Selector 实现）就像是给你这个单线程装上了一个超级“顺风耳”和高效的“任务调度系统”，让你能同时、高效地应付来自四面八方的“顾客”（网络连接），特别适合需要处理大量并发连接的服务器程序。
三、IO多路复用的代码实现
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;
/**
* 一个简单的 Java NIO 服务器示例，演示了 IO 多路复用。
* 它监听指定端口，接受客户端连接，并回显客户端发送的消息。
*/
public class NioServer {
private static final int PORT = 8080; // 服务器监听的端口
private static final int BUFFER_SIZE = 1024; // 缓冲区大小
public static void main(String[] args) {
Selector selector = null;
ServerSocketChannel serverSocketChannel = null;
try {
// 1. 创建 Selector
// Selector 是 NIO 的核心，用于轮询检查 Channel 的 IO 事件
selector = Selector.open();
// 2. 创建 ServerSocketChannel
// 用于监听客户端连接请求
serverSocketChannel = ServerSocketChannel.open();
// 3. 配置 ServerSocketChannel 为非阻塞模式
// 非阻塞模式下，accept() 方法会立即返回，即使没有新连接
serverSocketChannel.configureBlocking(false);
// 4. 绑定服务器端口
serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
System.out.println("服务器启动，监听端口: " + PORT);
// 5. 将 ServerSocketChannel 注册到 Selector
// 并指定我们关心 "接受连接" (OP_ACCEPT) 事件
// register 方法返回一个 SelectionKey 对象，代表了这个 Channel 和 Selector 的注册关系
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 6. 进入主循环，等待事件发生
while (true) {
// select() 方法会阻塞，直到至少有一个注册的 Channel 准备好进行 IO 操作，
// 或者发生错误，或者被唤醒 (selector.wakeup())
// 返回值是准备就绪的 Channel 的数量
int readyChannels = selector.select(); // 可以设置超时时间 select(timeout)
// 如果没有 Channel 就绪，继续下一次循环
if (readyChannels == 0) {
continue;
}
// 获取所有已就绪的 SelectionKey
// selectedKeys() 返回的是上次 select() 操作检测到的就绪事件集合
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
// 7. 遍历就绪的 SelectionKey
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
try {
// 根据 Key 的类型处理不同的 IO 事件
if (key.isAcceptable()) {
// 处理接受连接事件 (OP_ACCEPT)
handleAccept(key, selector);
} else if (key.isReadable()) {
// 处理读数据事件 (OP_READ)
handleRead(key);
}
// 还可以处理 isWritable() 和 isConnectable() 事件
} catch (IOException e) {
System.err.println("处理客户端连接时出错: " + e.getMessage());
// 当发生异常时（例如客户端强制关闭），取消注册并关闭通道
if (key != null) {
key.cancel();
if (key.channel() != null) {
try {
key.channel().close();
} catch (IOException cex) {
// 忽略关闭时的异常
}
}
}
}
// !!! 重要：处理完一个 key 后，必须将其从 selectedKeys 集合中移除
// 否则下次 select() 时，即使该事件已处理，它仍然会存在于集合中，导致重复处理
keyIterator.remove();
}
}
} catch (IOException e) {
System.err.println("服务器异常: " + e.getMessage());
e.printStackTrace();
} finally {
// 清理资源
try {
if (selector != null) {
selector.close();
}
if (serverSocketChannel != null) {
serverSocketChannel.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 处理接受新连接的事件
* @param key ServerSocketChannel 对应的 SelectionKey
* @param selector Selector 实例
* @throws IOException IO 异常
*/
private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
// 接受客户端连接
SocketChannel clientChannel = serverChannel.accept();
// 必须配置为非阻塞模式，才能注册到 Selector 上
clientChannel.configureBlocking(false);
// 将新的客户端 Channel 注册到 Selector，并监听读事件 (OP_READ)
clientChannel.register(selector, SelectionKey.OP_READ);
System.out.println("接受新连接: " + clientChannel.getRemoteAddress());
}
/**
* 处理从客户端读取数据的事件
* @param key SocketChannel 对应的 SelectionKey
* @throws IOException IO 异常
*/
private static void handleRead(SelectionKey key) throws IOException {
SocketChannel clientChannel = (SocketChannel) key.channel();
// 创建一个缓冲区用于读取数据
ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
int bytesRead = -1;
try {
// 从 Channel 读取数据到 Buffer
bytesRead = clientChannel.read(buffer);
} catch (IOException e) {
// 客户端可能强制关闭了连接
System.out.println("客户端连接异常断开: " + clientChannel.getRemoteAddress());
key.cancel(); // 取消注册
clientChannel.close(); // 关闭通道
return;
}
if (bytesRead > 0) {
// 读取到了数据
buffer.flip(); // 切换 Buffer 到读模式
byte[] bytes = new byte[buffer.remaining()];
buffer.get(bytes); // 将 Buffer 中的数据读入字节数组
String receivedMessage = new String(bytes).trim();
System.out.println("收到来自 " + clientChannel.getRemoteAddress() + " 的消息: " + receivedMessage);
// 回显消息给客户端
// 准备写回数据
ByteBuffer writeBuffer = ByteBuffer.wrap(("服务器收到: " + receivedMessage).getBytes());
clientChannel.write(writeBuffer); // 将数据写回客户端 Channel
// 如果客户端发送 "bye"，则关闭连接
if ("bye".equalsIgnoreCase(receivedMessage)) {
System.out.println("客户端 " + clientChannel.getRemoteAddress() + " 请求断开连接.");
key.cancel();
clientChannel.close();
}
} else if (bytesRead == -1) {
// 客户端正常关闭了连接 (read 返回 -1)
System.out.println("客户端 " + clientChannel.getRemoteAddress() + " 断开连接.");
key.cancel(); // 取消注册
clientChannel.close(); // 关闭通道
}
// 如果 bytesRead == 0，表示暂时没有数据可读，忽略即可
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
