复合+责任链示例

Question

谁能给出一个结合使用设计模式“组合”和“责任链”的实际例子吗？

谢谢

Answer 1

一个非常实际的例子是 GUI 设计，例如使用 Qt 框架。

QObject 可以是单个对象，也可以是多个对象的复合体。 QObject（理想情况下）知道它们的父 QObject，因此它们也形成了一个责任链。

例子：
主窗口有一个对话框（QObject）。
该对话框有一个输入行和一个布局框（所有 QObject）。
布局框有 2 个按钮（都是 QObject）。

按钮的事件（例如单击）将通过责任链传递，直到 QObject 可以处理该事件。

另一个方向也有效（由于复合设计）。对话框的 show() 将传递给子对象，因此输入行、布局框和按钮也将变得可见。

Answer 2

此示例结合了责任链、命令和复合，并利用了熟悉的Try*方法风格。网。

给定命令和处理程序类型：

public interface IResults { }

public interface ICommand { }

public interface IHandler
{
    Boolean TryHandle(ICommand command, out IResults results);
}

给定一些IHandler实现：

public class FooHandler : IHandler
{
    public Boolean TryHandle(ICommand command, out IResults results)
    {
        // ...
    }
}

public class BarHandler : IHandler
{
    public Boolean TryHandle(ICommand command, out IResults results)
    {
        // ...
    }
}

以及一个复合IHandler 实现：

public class CompositeHandler : IHandler
{
    public IList<IHandler> Handlers { get; } = new List<IHandler>();

    public Boolean TryHandle(ICommand command, out IResults results)
    {
        foreach (var handler in this.Handlers) {
            if (handler.TryHandle(command, out results)) {
                return true;
            }
        }
        results = null;
        return false;
    }
}

并在客户端代码中使用它：

var command = /* ... */;

var handler = new CompositeHandler();
handler.Handlers.Add(new FooHandler());
handler.Handlers.Add(new BarHandler());

IResults results;
if (handler.TryHandle(command, out results)) {
    // handled
}
else {
    // not handled
}

通过使用泛型，类型参数化/约束也可以确保一定程度的安全性：

public interface IResults { }

public interface ICommand<TResults>
    where TResults : IResults
{
    // ...
}

public interface IHandler<TCommand, TResults>
    where TCommand : ICommand<TResults>
    where TResults : IResults
{
    // ...
}

Answer 3

一个实际的答案可能是不可能的，但我可以看到你在哪里会有责任链的组成。这是一个Python风格的例子：

>>> class DevelopmentPerformanceMonitor():
...   def getPerformanceMonitorHandlers():
...     return []
... 
>>> class ProductionPerformanceMonitor():
...   def getPerformanceMonitorHandlers():
...     return [check_cpu_under_load, check_available_hd]
... 
>>> class DevelopmentExceptionMonitor():
...   def getExceptionHandlers():
...     return [email_local_root, log_exception]
... 
>>> class ProductionExceptionMonitor():
...   def getExceptionHandlers():
...     return [emails_system_admin, log_exception, create_ticket]
... 
>>> class SomeSystem:
...    pm = None # Performance Monitor
...    em = None # Exception Monitor
...    def __init__(self, performance_monitor, exception_monitor):
...      pm = performance_monitor
...      em = exception_monitor
...    def on_exception(e):
...      for handler in em.getExceptionHandlers():
...        handler(e)
...    def perform_performance_monitoring(s):
...      for handler in pm.getPerformanceMonitorHandlers():
...        handler(s)

所以SomeSystem对象是一个performance_monitor和一个exception_monitor的组合。每个组合将返回一系列处理程序以实现所需的责任链。尽管这个例子实际上只是使更简单的责任链变得复杂，其中 SomeSystem 可以用链本身来启动。尽管将它们包装起来可能会有所帮助。