设计模式（14）----- 责任链模式

概念：

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。

意图：

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

主要解决：

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

优点：

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

模式的结构

职责链模式主要包含以下角色。

抽象处理者（Handler）角色： 定义一个处理请求的接口，包含抽象处理方法和一个后继连接。

具体处理者（Concrete Handler）角色： 实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。

客户类（Client）角色： 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

实现类图

抽象处理者（Handler）角色：上级

public abstract class 上级
{
    protected string name;
    protected 上级 superior;
    public 上级(string name)
    {
        this.name = name;
    }
    //设置上级
    public void SetSuperior(上级 s)
    {
        this.superior = s;
    }
    /// <summary>
    /// 处理请求
    /// </summary>
    public abstract void RequestHandle(申请 request);
}

具体处理者（Concrete Handler）角色：
总经理

using System;

public class 总经理 : 上级
{
    public 总经理(string name) : base(name) { }
    public override void RequestHandle(申请 request)
    {
        Console.WriteLine("总经理：允许放假");
    }
}

总监

using System;

public class 总监 : 上级
{
    public 总监(string name) : base(name) { }
    public override void RequestHandle(申请 request)
    {
        if (request.Days <= 7)
        {
            Console.WriteLine("总监：允许放假");
        }
        else
        {
            Console.WriteLine("权限不够，帮你申请到总经理");
            if (superior != null)
            {
                superior.RequestHandle(request);
            }
        }
    }
}

经理

using System;

public class 经理 : 上级
{
    public 经理 (string name) : base(name) { }
    public override void RequestHandle(申请 request)
    {
        if (request.Days <= 3)
        {
            Console.WriteLine("经理：允许放假");
        }
        else
        {
            Console.WriteLine("权限不够，帮你申请到总监");
            if (superior != null)
            {
                superior.RequestHandle(request);
            }
        }
    }
}

客户类（Client）角色：申请

public class 申请
{
    //申请信息
    private string requestContent;
    //申请时间
    private int days;

    public string RequestContent { get => requestContent; set => requestContent = value; }
    public int Days { get => days; set => days = value; }
}

测试

using System;

class Program
{
    static void Main(string[] args)
    {
        总经理 m1 = new 总经理("总经理");
        总监 m2 = new 总监("总监");
        经理 m3 = new 经理("经理");

        m3.SetSuperior(m2);
        m2.SetSuperior(m1);

        申请 n = new 申请();
        n.RequestContent = "张三  因情  申请假期";
        n.Days = 2;

        m3.RequestHandle(n);

        申请 m = new 申请();
        m.RequestContent = "李四  因病  申请假期";
        m.Days = 365;

        m3.RequestHandle(m);

        Console.Read();
    }
}

输出示例

总结：

对于责任链中的一个处理者对象，有两个行为。一是处理请求，二是将请求传递到下一节点，不允许某个处理者对象在处理了请求后又将请求传送给上一个节点的情况。