用Python设计异步API'；s异步

我曾经在Java中与Netty合作，我非常喜欢它的概念和工作方式。现在，我正在从事一个Python项目，我需要设计一个能够在许多不同传输层上异步执行IO操作的API

我决定创造一些类似于Netty的东西。当然，我知道Netty是一个非常庞大的项目，我永远无法模仿它的出色特性，但我只想在Python的asyncio之上实现它的一些基本功能

以下是我目前得到的信息：

from .utility import Next

__all__ = [
    "ChannelHandler", "InboundHandler", "OutboundHandler",
    "Pipeline", "Channel"
]

class ChannelHandler:

    async def connected(self, channel):
        raise NotImplementedError()

    async def raised(self, channel, exception):
        raise NotImplementedError()

    async def disconnected(self, channel):
        raise NotImplementedError()

class InboundHandler:

    async def received(self, channel, data, next):
        raise NotImplementedError()

class OutboundHandler:

    async def sent(self, channel, message, next):
        raise NotImplementedError()

class Pipeline:

    def __init__(self, channel, channel_handler, inbound_handlers, outbound_handlers):
        self.channel = channel
        self.channel_handler = channel_handler
        self.inbound_handlers = inbound_handlers
        self.outbound_handlers = outbound_handlers

    async def handle_raise_event(self, exception):
        await self.channel_handler.raised(channel, exception)

    async def handle_receive_event(self, data):
        await Next(self.inbound_handlers).next(self.channel, data)

    async def handle_send_event(self, message):
        await Next(self.outbound_handlers).next(self.channel, message)

class Channel:

    def __init__(self, url, channel_handler, inbound_handlers, outbound_handlers, options={}):
        self.url = url
        self.pipeline = Pipeline(self, channel_handler, inbound_handlers, outbound_handlers)
        self.options = options

    async def connect(self):
        pass

    async def send(self, message):
        pass

    async def disconnect(self):
        pass

async def connect(url, channel_handler, inbound_handlers, outbound_handlers, options={}):
    pass

这是核心API模块。下面是一个如何使用它的示例：

import asyncio
import transport

class DummyChannelHandler:

    async def connected(self, channel):
        print("Connected.")

    async def raised(self, channel, exception):
        print("Error:", exception)
        await channel.disconnect()

    async def disconnected(self, channel):
        print("Disconected.")

class DummyInboundHandler:

    async def received(self, channel, data, next):
        print("Received:", data)

class DummyOutboundHandler:

    async def sent(self, channel, message, next):
        await channel.write(message.encode())

async def main():
    channel = await transport.connect(
        "udp://192.168.20.244:55300",
        DummyChannelHandler(),
        [DummyInboundHandler()],
        [DummyOutboundHandler()]
    )

    await channel.send("Hi!")

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()

正如我所说，我对asyncio非常陌生。我想问一下你们的机会，我非常感谢你们的建议。比如，这就是

asyncio

应该使用的方式吗？还是我完全没有抓住重点？这可能有效吗？还有一些同步问题呢？我知道锁、队列之类的东西，但我不清楚如何使用

asyncio

我不知道API的设计是否正确。例如，我不太确定关键字

async

是否在正确的位置使用。等待也是如此

---

如果你碰巧发现了什么，请给我留言，谢谢

您好，欢迎收看stackoverflow。您的问题很有趣，imho应该得到一个答案，但是对于堆栈溢出预期的QA来说，它太宽泛了，因为这是一个设计问题，有多少人来回答它，就会有多少好的答案。所以我投票赞成结束它☹是的，当然，我明白。我只是好奇别人的机会，因为在这一点上，我真的很困惑。即使在阅读了一些asyncio教程之后，我似乎也无法继续这样做。如果有人能提供一点帮助，或者仅仅是一个不同的观点，我想这对我会有很大的帮助。但当然，我明白这不是一个真正的“问题”。当你说“能够在多个不同的传输层上异步执行IO操作”时，我会尽力帮助你，你真的是指传输，还是指协议，我想你指的是协议，否则我有点困惑。传输是UDP、TCP等的实现，其中协议用于实现通信方案、处理HTTP流量、IMAP等，或您定义的自定义行为。echo服务器就是一个例子，它是一个只回显输入的协议。事实上，我是说两者都有。用户应该能够使用

ChannelHandler

、

InboundHandler

和

OutboundHandler

指定他们的协议。但是，我仍然需要实现传输层，如UDP、TCP等。我想做的是使用

asyncio

已经提供的实现，并将它们包装在我上面提出的API中。我的问题是我真的不知道怎么做。您好，欢迎收看stackoverflow。您的问题很有趣，imho应该得到一个答案，但是对于堆栈溢出预期的QA来说，它太宽泛了，因为这是一个设计问题，有多少人来回答它，就会有多少好的答案。所以我投票赞成结束它☹是的，当然，我明白。我只是好奇别人的机会，因为在这一点上，我真的很困惑。即使在阅读了一些asyncio教程之后，我似乎也无法继续这样做。如果有人能提供一点帮助，或者仅仅是一个不同的观点，我想这对我会有很大的帮助。但当然，我明白这不是一个真正的“问题”。当你说“能够在多个不同的传输层上异步执行IO操作”时，我会尽力帮助你，你真的是指传输，还是指协议，我想你指的是协议，否则我有点困惑。传输是UDP、TCP等的实现，其中协议用于实现通信方案、处理HTTP流量、IMAP等，或您定义的自定义行为。echo服务器就是一个例子，它是一个只回显输入的协议。事实上，我是说两者都有。用户应该能够使用

ChannelHandler

、

InboundHandler

和

OutboundHandler

指定他们的协议。但是，我仍然需要实现传输层，如UDP、TCP等。我想做的是使用

asyncio

已经提供的实现，并将它们包装在我上面提出的API中。我的问题是，我真的不知道怎么做。