Question

想象一下两个类TypeAServer和TypeBServer实现某种功能，需要在某些事件的情况下调用方法。除了提供离散的回调函数，当我想实现复合行为时，我可以想到两种略有不同的方法：

class TypeAServer(ABC):
    def __init__(self):
        do some stuff

    @abstractmethod
    def on_type_a_event(self, event):
        ''' will be called when event type A occurs '''

    def some_message_generating_method(self):
        ...
        self._handler.on_type_a_event(e)

class TypeBServer(ABC):
    def __init__(self):
        do some stuff

    @abstractmethod
    def on_type_b_event(self, event):
        ''' will be called when event type A occurs '''

    def some_message_generating_method(self):
        ...
        self._handler.on_type_b_event(e)

class CompositeServer(TypeAServer, TypeBServer):
    def __init__(self):
        TypeAServer.__init__(self)
        TypeBServer.__init__(self)

    def on_type_a_event(self, event):
        # implement reaction of event type A

    def on_type_b_event(self, event):
        # implement reaction of event type B

在这种情况下，我只是使用抽象方法继承类，以实现所需的行为。

然而 - 当我不想直接继承TypeAServer和TypeBServer时，我也可以采用这样的基于组合的方法：

class TypeAServer:
    class Handler(ABC):
        @abstractmethod
        def on_type_a_event(self, event):
            ''' will be called when event type A occurs '''

    def __init__(self, handler):
        self._handler = handler
        # do some other stuff

    def some_message_generating_method(self):
        ...
        self._handler.on_type_a_event(e)

class TypeBServer:
    class Handler(ABC):
        @abstractmethod
        def on_type_a_event(self, event):
            ''' will be called when event type A occurs '''

    def __init__(self, handler):
        self._handler = handler

    def some_message_generating_method(self):
        ...
        self._handler.on_type_b_event(e)

class CompositeServer(TypeAServer.Handler, TypeBServer.Handler):
    def __init__(self):
        self.type_a_server = TypeAServer(handler=self)
        self.type_b_server = TypeAServer(handler=self)

    def on_type_a_event(self, event):
        # implement reaction of event type A

    def on_type_b_event(self, event):
        # implement reaction of event type B

第二个例子与第一个例子非常相似，但它有一些众所周知的好处（参见组合而不是继承）：

我可以决定何时设置服务器实例
我甚至可以动态添加更多
测试更简单
内部调用方法的名称冲突不太可能

我的问题现在是：我知道像组合和接口这样的术语 - 但是有一个模式用于“注入”实现的对象构造上的“处理程序接口”（与通过继承隐式提供处理程序相反）？

Answer 1

对TypeAServer（和TypeBServer）所做的更改，具有单独的listener object，可以被视为dependency injection的一种形式：而不是服务器“创建”自己的处理程序（读取：使用自身作为处理程序），为其构造函数提供一个。

然后创建CompositeServer一次是两种组合：

它结合了两个处理程序：实现是通过多重继承实现的，但同样可以使用adapter pattern实现，其中两个处理程序共享基础状态。
它由两台服务器组成，证明其名称。

（未经请求的建议如下。）从这么多代码中不清楚为什么你不会只使用第一个点（并称之为CompositeHandler），将服务器构造留给客户。该客户端本身可以组成服务器和处理程序，但它不必这样做。

是否有一个名称/模式的类调用抽象处理程序方法

1 个答案: