设计模式 13 责任链模式

设计模式 13

创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式
行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式

文章目录

设计模式 13
- 责任链模式（Chain of Responsibility Pattern）
- - 1 定义
  - 2 结构
  - 3 示例代码
  - 5 特点
  - 6 适用场景
  - 7 总结

责任链模式（Chain of Responsibility Pattern）

1 定义

责任链模式的核心思想是将请求沿着处理者链传递，直到其中一个处理者处理这个请求。这种模式的一个重要特性是：请求的发送者并不知道哪个对象会最终处理请求，系统中的处理者对象也无需知道其他处理者的结构，处理者之间的解耦提高了系统的灵活性。

2 结构

责任链模式包含以下角色：

抽象处理者（Handler）: 定义一个处理请求的接口，并且实现链中下一个处理者的引用。
具体处理者（ConcreteHandler）: 具体实现抽象处理者，处理请求或者将请求传递给链中的下一个处理者。
客户端（Client）: 负责将请求发送到链中的第一个处理者，通常不关心请求的最终处理者是谁。

UML 类图

+-----------------------------------+
|    Handler                        |  <----- 抽象处理者
+-----------------------------------+
| - next: Handler                   |  <----- 链中下一个处理者的引用
| + SetNext(handler: Handler)       |
| + HandleRequest(request: Request) |
+-----------------------------------+^|
+-----------------------------------+    +-----------------------------------+
|  ConcreteHandler1                 |    |  ConcreteHandler2                 |
+-----------------------------------+    +-----------------------------------+
| + HandleRequest(request: Request) |    | + HandleRequest(request: Request) |
+-----------------------------------+    +-----------------------------------+

3 示例代码

假设我们有一个支持多级审批的系统，每个级别的审批员处理不同级别的请求。请求可以从一个审批员传递到下一个审批员，直到某个审批员处理了请求或者请求被拒绝。

抽象处理者

// 抽象处理者
public abstract class Approver
{protected Approver _nextApprover;public void SetNext(Approver nextApprover){_nextApprover = nextApprover;}public abstract void ProcessRequest(PurchaseRequest request);
}

具体处理者

// 具体处理者1：经理
public class Manager : Approver
{public override void ProcessRequest(PurchaseRequest request){if (request.Amount < 10000){Console.WriteLine($"{this.GetType().Name} approved request# {request.Number}");}else if (_nextApprover != null){_nextApprover.ProcessRequest(request);}}
}// 具体处理者2：总监
public class Director : Approver
{public override void ProcessRequest(PurchaseRequest request){if (request.Amount < 25000){Console.WriteLine($"{this.GetType().Name} approved request# {request.Number}");}else if (_nextApprover != null){_nextApprover.ProcessRequest(request);}}
}// 具体处理者3：副总裁
public class VicePresident : Approver
{public override void ProcessRequest(PurchaseRequest request){if (request.Amount < 50000){Console.WriteLine($"{this.GetType().Name} approved request# {request.Number}");}else if (_nextApprover != null){_nextApprover.ProcessRequest(request);}}
}// 具体处理者4：总裁
public class President : Approver
{public override void ProcessRequest(PurchaseRequest request){if (request.Amount < 100000){Console.WriteLine($"{this.GetType().Name} approved request# {request.Number}");}else{Console.WriteLine($"Request# {request.Number} requires an executive meeting!");}}
}

请求类

// 请求类：采购请求
public class PurchaseRequest
{public int Number { get; }public double Amount { get; }public string Purpose { get; }public PurchaseRequest(int number, double amount, string purpose){Number = number;Amount = amount;Purpose = purpose;}
}

客户端代码

class Program
{static void Main(string[] args){// 创建处理者对象Approver manager = new Manager();Approver director = new Director();Approver vp = new VicePresident();Approver president = new President();// 设置责任链manager.SetNext(director);director.SetNext(vp);vp.SetNext(president);// 创建多个采购请求PurchaseRequest request1 = new PurchaseRequest(1, 5000, "Buy supplies");PurchaseRequest request2 = new PurchaseRequest(2, 20000, "Buy projectors");PurchaseRequest request3 = new PurchaseRequest(3, 35000, "Buy laptops");PurchaseRequest request4 = new PurchaseRequest(4, 90000, "Buy servers");// 处理请求manager.ProcessRequest(request1);manager.ProcessRequest(request2);manager.ProcessRequest(request3);manager.ProcessRequest(request4);}
}

运行结果

Manager approved request# 1
Director approved request# 2
VicePresident approved request# 3
President approved request# 4

在这个例子中，Manager、Director、VicePresident 和 President 这四个处理者构成了一个责任链。每个处理者都检查请求的金额，并决定是否可以处理请求，如果不能处理则将请求传递给下一个处理者。

5 特点

优点:
- 降低耦合度: 客户端不需要知道哪个处理者会最终处理请求，这使得系统更灵活、可扩展。
- 增加灵活性: 可以动态地添加或移除处理者，甚至可以动态调整处理者链的顺序。
- 职责分离: 每个处理者只关注自己能够处理的那部分职责，符合单一职责原则。
缺点:
- 不保证请求被处理: 如果链上的处理者都不能处理请求，那么请求可能会被丢弃。
- 可能影响性能: 如果责任链过长，或者某些处理者链路中的节点过多，可能导致请求处理的延迟。