写一个 TCP 服务器,用原生 Java AIO 十行代码就有一堆回调地狱:连接完成回调里发起读,读完成回调里再发起下一次读,稍不留神就丢事件或者死循环。t-io 的内核层就是来解决这件事的。这篇拆 AIO 内核:AsynchronousServerSocketChannel 怎么被封装,CompletionHandler 回调体系怎么组织。
前置阅读:12.2 讲过 Netty 的 Reactor。这篇看 t-io 走 AIO 路线的内核编程。
假设你做一个物联网网关,几万个设备长连接上来,随时推数据。用原生 AIO 写,你得自己管:accept 之后注册读回调、读回调里处理粘包、写完再继续注册读……代码全缠在回调里。
t-io 把这层彻底封死了。业务只需要实现三个方法:decode、encode、handler,其余全由框架接管。
把 AIO 内核类比成一家餐厅:
AsynchronousServerSocketChannel 是门口的迎宾(只管把客人领进门)AcceptCompletionHandler 是迎宾的对讲机(客人到了通知大堂)ReadCompletionHandler 是每桌的服务员(盯着客人说话)WriteCompletionHandler 是上菜员(菜好了端出去,端完继续待命)关键在于:每桌有专属服务员,服务员只服务一桌,互不干扰。这就是后面要讲的「每连接独立任务对象」的雏形。
// 1. 定义协议包:继承抽象类 Packet
public class DemoPacket extends Packet {
private byte[] body;
// getter/setter 省略
}
再实现三个钩子,其余全部由框架接管。先看最要紧的 decode:
public class DemoHandler implements TioHandler {
@Override
public Packet decode(ByteBuffer buffer, int limit, int position,
int readableLength, ChannelContext ctx) {
// 简化协议:前 4 字节是长度
if (readableLength < 4) return null; // 数据不够,等下一次(自动续包)
int len = buffer.getInt(0);
if (readableLength < len + 4) return null; // 半包,继续攒
buffer.getInt();
byte[] body = new byte[len];
buffer.get(body);
DemoPacket p = new DemoPacket();
p.setBody(body);
return p;
}
encode 与 handler 就朴素了,一个打包一个处理:
@Override
public ByteBuffer encode(Packet packet, TioConfig config, ChannelContext ctx) {
DemoPacket p = (DemoPacket) packet;
ByteBuffer buf = ByteBuffer.allocate(4 + p.getBody().length);
buf.putInt(p.getBody().length);
buf.put(p.getBody());
buf.flip();
return buf;
}
@Override
public void handler(Packet packet, ChannelContext ctx) throws Exception {
System.out.println("收到: " + new String(((DemoPacket) packet).getBody()));
Tio.send(ctx, packet); // 门面 API:原样回发
}
}
最后三行启动:
TioServerConfig config = new TioServerConfig("127.0.0.1", 8888, new DemoHandler());
TioServer server = new TioServer(config);
server.start();
注意 decode 返回 null 的写法——这就是 t-io 处理粘包/半包(TCP 把多条消息挤在一个包里、或一条消息被拆成多段的现象)的契约:返回 null 表示「数据还不足,框架替你攒着」。
Proactor 模式(完成事件模式:内核先把 IO 做完,再通知你「已完成」,区别于 NIO Reactor 的「就绪了你自己来做」)是 AIO 的本质。t-io 用四个回调类撑起整个骨架:
| 类 | 职责 |
|---|---|
AcceptCompletionHandler | 服务端接收连接完成 |
ReadCompletionHandler | 读数据完成 |
WriteCompletionHandler | 写数据完成 |
ConnectionCompletionHandler | 客户端连接完成 |
以读路径为例,源码在 org.tio.core.ReadCompletionHandler:
1. 操作系统读完数据,回调 completed(ByteBuffer, ChannelContext)
2. 框架判断 sslFacadeContext == null 决定走明文还是 SSL 解密——对上层完全透明
3. 解密后的字节交给该连接专属的 DecodeRunnable(一个连接一个,投递到解码线程池)
4. 解码产出业务包后,交给 HandlerRunnable 处理
5. 最后立刻再次发起 read(),注册下一次读完成事件——这就是 AIO 的事件循环:不靠 select 轮询,靠「完成一次、续挂一次」
写路径对称:Tio.send() 把包丢进该连接的 SendRunnable 队列,编码后调用 channel.write(),完成回调在 WriteCompletionHandler 里收尾。
几个设计模式在这层的落点:
Tio.java 提供 Tio.send / Tio.bSend / Tio.synSend / Tio.bindUser / Tio.sendToGroup 等静态方法,业务几乎只跟它打交道TioListener 监听连接建立、收到字节、解码后、发送后、关闭前等生命周期事件;DefaultTioListener 提供空实现当默认适配器PacketConverter 做协议适配;SSL 用 SslFacadeContext 包装加解密,是装饰器框架不绑定任何应用层协议,靠的是 Packet 这个抽象基类。业务继承它定义自己的协议包,加自己的字段。这带来一个关键能力:同一个内核既能跑 IM 私有协议,也能跑 MQTT、HTTP、WebSocket——zoo 目录下这些协议实现全是搭在 core 内核上的「外挂」。
Packet 里有几个框架级字段值得认识:
id:全局 AtomicLong 生成的唯一 ID(享元倾向,全 JVM 共用一个计数器)synSeq:同步请求-响应的配对序列号Meta.countDownLatch:阻塞发送 bSend() 用的倒计时门闩preEncodedByteBuffer:预编码缓存,同一包群发时避免重复 encodeTCP 和 UDP 也做了统一抽象:udp 包把 UDP 的收发适配成同样的 Packet 流,业务代码换一个配置就能在 TCP 和 UDP 之间切换,上层完全无感。
TioServer.start() 起来之后发生的事,按顺序捋一遍:
1. 创建 AsynchronousServerSocketChannel,绑定端口
2. 调用 accept() 并传入 AcceptCompletionHandler——注意 AIO 的 accept 也要传回调
3. 新连接到达,AcceptCompletionHandler.completed() 里构造 ChannelContext,为它创建专属的三个任务对象
4. 立即再次调用 accept(),等下一个连接
5. 对新连接发起第一次 read(),挂上 ReadCompletionHandler,读循环就此启动
客户端侧对称:ConnectionCompletionHandler 负责连接完成,连上后同样进入读循环;断线由 ReconnRunnable 按配置的间隔自动重连。
先说一个总纲,帮你把整篇串起来:t-io 内核的本质是「回调只做搬运,队列负责串行,门面负责易用」。回调体系里的每个 CompletionHandler 都遵循同一条纪律——尽快把数据交给该连接的任务对象,然后立刻返回去挂下一次事件;真正干活的是线程池里的队列消费者。理解了这条纪律,后面任何网络框架的源码你都能快速定位入口。
再说一个使用建议:如果你的业务是海量短连接(比如每秒几千次建连断连的探活类场景),AIO 的 accept 回调链反而是优势——连接建立本身就是一次完成事件,不需要像 Reactor 那样在就绪集合里反复筛选。而如果是超低延迟的交易类场景,AIO 在 Linux 上的 epoll 模拟层会多一层间接,需要实测再选型。框架没有银弹,t-io 的甜蜜点是 IoT、IM 这类海量长连接 + 中等消息频率的业务,它的内置能力(绑定、心跳、重连、监控)恰好都为这类场景服务。
ReadCompletionHandler.completed() 是内核线程触发的,耗时会拖慢整个事件派发,重逻辑必须丢给 DecodeRunnable/HandlerRunnablePacket.clone() 会清状态:一个包发给多个连接时框架会克隆,克隆时清掉 preEncodedByteBuffer 和 isSslEncrypted,别在子类里依赖这两个字段跨克隆传递「AIO 和 NIO 的区别?」——答:NIO 是 Reactor,告诉你「可以读了」还得自己读;AIO 是 Proactor,内核读完把结果直接回调给你。t-io 用 AsynchronousServerSocketChannel 加四个 CompletionHandler 回调类搭出事件骨架,每次完成回调末尾再挂下一次操作形成事件循环。
「t-io 怎么处理粘包半包?」——答:契约放在业务 decode() 里,返回 null 表示数据不足,框架用 lastByteBuffer 把上次没消费完的字节和新字节 composite 后再解,业务零成本续包。