Python / 系统课时
用协议接口处理复杂 Socket
用协议接口处理复杂 Socket
Streams API 适合大多数按“读一段、写一段”组织的 TCP 程序,但有些协议更依赖连接事件、原始缓冲区和细粒度流量控制。asyncio 的 Protocol 与 Transport 把“协议状态机”和“底层 I/O”分开:Protocol 接收回调,Transport 负责实际收发与关闭,适合实现网络库或复杂连接协议。
学习目标
- 理解
Protocol与Transport的职责,以及它们与 Stream API 的层级关系 - 能使用
loop.create_server()和自定义Protocol处理连接、数据与断开事件 - 能判断什么时候应继续使用 Streams,什么时候低层协议接口更合适
Protocol 处理事件,Transport 执行 I/O
asyncio.Protocol 是回调式接口。事件循环在连接状态变化时调用协议对象的方法,例如 connection_made()、data_received() 和 connection_lost()。这些方法描述“发生了什么”。
Transport 则表示已经建立的传输通道。Protocol 通常会在 connection_made() 中保存 Transport,随后通过 transport.write() 发送数据,通过 transport.close() 发起关闭。它描述“如何把字节交给底层 I/O”。

可以把两者理解成明确的职责边界:Protocol 保存协议状态并响应事件,Transport 隐藏具体套接字与事件循环实现。应用不需要在 data_received() 里直接调用 socket.recv()。
Streams API 位于更高层,提供 await reader.read()、writer.write()、await writer.drain() 这样的协程式接口。它更接近顺序程序的写法;Protocol/Transport 则更接近事件驱动状态机。
一个完整的 Protocol 回显服务
下面的示例同时创建低层 Protocol 服务端和 Protocol 客户端。客户端连接成功后发送 ping,服务端收到数据后写回 echo:ping,客户端收到完整响应后主动关闭。
import asyncio
class EchoServerProtocol(asyncio.Protocol):
def __init__(
self,
received: asyncio.Future[str],
closed: asyncio.Future[None],
) -> None:
self.received = received
self.closed = closed
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.transport = transport
def data_received(self, data: bytes) -> None:
message = data.decode()
if not self.received.done():
self.received.set_result(message)
transport = self.transport
assert isinstance(transport, asyncio.Transport)
# write 进入发送缓冲区;close 会在缓冲数据发送后关闭传输。
transport.write(b"echo:" + data)
transport.close()
def connection_lost(self, exc: Exception | None) -> None:
if not self.closed.done():
if exc is None:
self.closed.set_result(None)
else:
self.closed.set_exception(exc)
class EchoClientProtocol(asyncio.Protocol):
def __init__(self, done: asyncio.Future[str]) -> None:
self.done = done
self.buffer = bytearray()
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.transport = transport
assert isinstance(transport, asyncio.Transport)
transport.write(b"ping")
def data_received(self, data: bytes) -> None:
self.buffer.extend(data)
def connection_lost(self, exc: Exception | None) -> None:
if not self.done.done():
if exc is None:
self.done.set_result(self.buffer.decode())
else:
self.done.set_exception(exc)
async def main() -> None:
loop = asyncio.get_running_loop()
received = loop.create_future()
server_closed = loop.create_future()
client_done = loop.create_future()
server = await loop.create_server(
lambda: EchoServerProtocol(received, server_closed),
"127.0.0.1",
0,
)
port = server.sockets[0].getsockname()[1]
async with server:
await loop.create_connection(
lambda: EchoClientProtocol(client_done),
"127.0.0.1",
port,
)
client_result = await client_done
server_message = await received
await server_closed
print(f"server: received {server_message}")
print(f"client: {client_result}")
print("server: disconnected")
if __name__ == "__main__":
asyncio.run(main())预期输出
server: received ping
client: echo:ping
server: disconnected回调式接口的关键边界
Protocol 最重要的限制是:它的事件方法不是协程,不能在 data_received() 里直接写 await some_coroutine()。如果某个事件需要启动异步业务,可以用 asyncio.create_task() 把工作交给独立 Task,并自行管理异常、取消和生命周期。
另一个边界是分包。data_received(data) 的一次回调不等于一条完整业务消息。TCP 仍然只是字节流:一条消息可能拆成多次回调,多条消息也可能合并到一次回调。复杂协议必须自己维护缓冲区并按长度字段、分隔符或其他 framing 规则解析。
Transport 的 write() 同样不是“数据已到达对端”的证明。它只是把字节交给传输层。高吞吐场景还应关注写缓冲区和流量控制;Protocol 可通过 pause_writing()、resume_writing() 接收背压相关通知,而不是无限制地产生待发送数据。
Streams 与 Protocol 怎么选
如果业务主要是请求读取、响应写回、按行读取或固定长度读取,Streams 通常更直接。它把底层回调包装成可 await 的读写接口,错误处理和控制流也更符合普通异步函数的写法。
Protocol/Transport 更适合以下情况:你在编写网络库或协议实现,需要直接接收连接事件;协议本身具有复杂状态机;希望精细控制发送缓冲与背压;或者要减少高层封装带来的额外状态转换。
选择低层接口的代价也很明确:你必须自己处理分帧、状态机、异步任务衔接和关闭边界。它不是 Streams 的“升级版”,而是一组更靠近事件循环的原语。只有当这些额外控制确实能解决问题时,复杂度才值得承担。