设计模式<结构型> | 责任链模式

责任链模式(Chain of Responsibility Pattern)

将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

结构图：

角色：

1. 抽象处理者(Handler)：声明了所有具体处理者的通用接口。 该接口通常仅包含单个方法用于请求处理， 有时其还会包含一个设置链上下个处理者的方法。
2. 基本处理者(Base Handler)：是一个可选的类， 将所有处理者共用的样本代码放置在其中
3. 具体处理者(Concrete Handlers)：包含处理请求的实际代码。 每个处理者接收到请求后， 都必须决定是否进行处理， 以及是否沿着链传递请求。

适用场景：

1. 业务执行顺序预先未知时。
2. 业务执行顺序需要再运行时改变时。

优点：

1. 可控的执行顺序。
2. 对发起操作和执行操作的类进行解耦，符合单一原则。
3. 可以在不更改现有代码的情况下在程序中新增处理者，符合开闭原则。

缺点：

1. 不能保证每个请求一定被处理。
2. 职责链由客户端维护，增加客户端复杂度。

代码(C#)

// 抽象处理者
public interface IHandler
{
    bool Handel();
    IHandler SetNext(IHandler handler);
}

// 基本处理者
public abstract class AbstractHandler : IHandler
{
    protected IHandler _next;

    public virtual bool Handel()
    {
        return _next.Handel();
    }

    public IHandler SetNext(IHandler handler)
    {
        _next = handler;
        return handler;
    }
}

// 具体处理者
public class HandlerA : AbstractHandler
{
    public override bool Handel()
    {
        Console.WriteLine("HandlerA");
        if (_next != null)
            return _next.Handel();
        else
            return false;
    }
}

public class HandlerB : AbstractHandler
{
    public override bool Handel()
    {
        Console.WriteLine("HandlerB");
        if (_next != null)
            return _next.Handel();
        else
            return false;
    }
}

public class HandlerC : AbstractHandler
{
    public override bool Handel()
    {
        Console.WriteLine("HandlerC");
        if (_next != null)
            return _next.Handel();
        else
            return true;
    }
}

AbstractHandler a = new HandlerA();
AbstractHandler b = new HandlerB();
AbstractHandler c = new HandlerC();
a.SetNext(b).SetNext(c);
a.Handel();

最后

责任链分为纯的和不纯的，纯的责任链要求责任链中的对象要么处理请求要么向下转发请求，不能出现请求未被任何一个责任链中的对象处理的情况，不纯的责任链则允许请求被某一个对象部分处理后继续向下转发，或者某一个对象处理完成后继续交给下一个对象处理，且允许一个请求最终不被任何对象处理。 在实际开发中不纯的责任链用的最多。