← 课程目录 🚀 从零到一
📐 学习维度 阶段7 · 第28章 开源项目源码精读 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

28.16.1 t-io 源码深读:AIO 内核编程与 CompletionHandler 回调体系

审校 2026-09-26 · 素材来源:zcode会话《分析代码设计模式与作用》(项目源码分析)
📑 本篇章节导航 (共6节,点击直达)
场景:一个连接从进门到收到数据类比:餐厅的服务流程可跑示例:一个最小的 t-io 服务端原理:四个 CompletionHandler 组成的 Proactor踩坑清单面试怎么问

写一个 TCP 服务器,用原生 Java AIO 十行代码就有一堆回调地狱:连接完成回调里发起读,读完成回调里再发起下一次读,稍不留神就丢事件或者死循环。t-io 的内核层就是来解决这件事的。这篇拆 AIO 内核:AsynchronousServerSocketChannel 怎么被封装,CompletionHandler 回调体系怎么组织。

前置阅读:12.2 讲过 Netty 的 Reactor。这篇看 t-io 走 AIO 路线的内核编程。

场景:一个连接从进门到收到数据

假设你做一个物联网网关,几万个设备长连接上来,随时推数据。用原生 AIO 写,你得自己管:accept 之后注册读回调、读回调里处理粘包、写完再继续注册读……代码全缠在回调里。

t-io 把这层彻底封死了。业务只需要实现三个方法:decode、encode、handler,其余全由框架接管。

类比:餐厅的服务流程

把 AIO 内核类比成一家餐厅:

关键在于:每桌有专属服务员,服务员只服务一桌,互不干扰。这就是后面要讲的「每连接独立任务对象」的雏形。

可跑示例:一个最小的 t-io 服务端


// 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 表示「数据还不足,框架替你攒着」。

原理:四个 CompletionHandler 组成的 Proactor

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 里收尾。

几个设计模式在这层的落点:

Packet 与协议无关设计

框架不绑定任何应用层协议,靠的是 Packet 这个抽象基类。业务继承它定义自己的协议包,加自己的字段。这带来一个关键能力:同一个内核既能跑 IM 私有协议,也能跑 MQTT、HTTP、WebSocket——zoo 目录下这些协议实现全是搭在 core 内核上的「外挂」。

Packet 里有几个框架级字段值得认识:

TCP 和 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 这类海量长连接 + 中等消息频率的业务,它的内置能力(绑定、心跳、重连、监控)恰好都为这类场景服务。

踩坑清单

面试怎么问

「AIO 和 NIO 的区别?」——答:NIO 是 Reactor,告诉你「可以读了」还得自己读;AIO 是 Proactor,内核读完把结果直接回调给你。t-io 用 AsynchronousServerSocketChannel 加四个 CompletionHandler 回调类搭出事件骨架,每次完成回调末尾再挂下一次操作形成事件循环。

「t-io 怎么处理粘包半包?」——答:契约放在业务 decode() 里,返回 null 表示数据不足,框架用 lastByteBuffer 把上次没消费完的字节和新字节 composite 后再解,业务零成本续包。