【设计模式】职责链模式

职责链可能是一条直线、一个环链或者一个树结构的一部分。

客户端发出一个请求，会有很多对象都可以来处理这个请求，而且不同对象的处理逻辑是不一样的。
对于客户端而言，无所谓谁来处理，反正有对象处理就可以了。而且在上述处理中，还希望处理流程是可以灵活变动的，而处理请求的对象需要能方便地修改或者是被替换掉，以适应新的业务功能的需要。

职责链（Chain of Responsibility）模式

本质：分离职责，动态组合

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

责任链模式降低了请求的发送端和接收端之间的耦合，使多个对象都有机会处理这个请求。一个链可以是一条线，一个树，也可以是一个环。

原理其实与数据结构中的链表类似。

动态构建流程步骤(也就是修改后继节点的指针)，这样随时可以重新组合出新的流程，非常灵活。

在Handler抽象类中存有一个指向本类类型的引用，也就相当于在数据结构中的链表，存有一个后继节点的指针。

• 抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法，以设定和返回对下家的引用。这个角色通常由一个抽象类或接口实现。
• 具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

处理过程：

ConcreteHandler将自己的后继对象（向下传递消息的对象）记录在自己的后继表
中，当一个请求到来时，ConcreteHandler会先检查看自己有没有匹配的处理程序，如果有就自己处理，否则传递给它的后继。

示意性代码：

abstract class Handler
{
    protected Handler successor;
    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }
    public abstract void HandleRequest(int request);
}

class ConcreteHandler1 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine("{0} 处理请求{1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine("{0} 处理请求{1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

class ConcreteHandler3 : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 20 && request < 30)
        {
            Console.WriteLine("{0} 处理请求{1}",
                              this.GetType().Name, request);
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.SetSuccessor(h2);
        h2.SetSuccessor(h3);
        int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };
        foreach (int request in requests)
        {
            h1.HandleRequest(request);
        }
        Console.Read();
    }
}

优缺点

优点：

• 请求者和接收者松散耦合
• 动态组合职责

缺点：

• 产生很多细粒度对象
• 不一定能被处理
  – 需要提供默认处理

与状态模式的区别

• 状态模式是一个对象的内在状态发生改变，一个对象，相对比较稳定，处理完一个对象下一个对象的处理一般都已确定。在某个状态中已经确定了下一个状态（写死了，如果需要修改，需要打开每个类，进行修改，不符合开放封闭）

• 职责链模式过于灵活，在客户端使用时，需要环境去确定下一个对象是谁，进行一系列的set操作……。职责链模式是多个对象之间的改变，就会出现某个对象不存在的情景。