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”。

asyncio Protocol、Transport、Socket 与 Streams 的关系

可以把两者理解成明确的职责边界:Protocol 保存协议状态并响应事件,Transport 隐藏具体套接字与事件循环实现。应用不需要在 data_received() 里直接调用 socket.recv()。

Streams API 位于更高层,提供 await reader.read()、writer.write()、await writer.drain() 这样的协程式接口。它更接近顺序程序的写法;Protocol/Transport 则更接近事件驱动状态机。

一个完整的 Protocol 回显服务

下面的示例同时创建低层 Protocol 服务端和 Protocol 客户端。客户端连接成功后发送 ping,服务端收到数据后写回 echo:ping,客户端收到完整响应后主动关闭。

python
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())

预期输出

text
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 的“升级版”,而是一组更靠近事件循环的原语。只有当这些额外控制确实能解决问题时,复杂度才值得承担。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用协议接口处理复杂 Socket

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通