责任链设计模式

责任链设计模式（过滤器、拦截器）责任链设计模式（Chain of Responsibility）的应⽤有：Java Web中的过滤器链、Struts2中的拦截器栈。

先看⼀个问题：给定⼀个字符串“被就业了：)，敏感信息，<script>”，对其中的HTML标记和敏感词进⾏过滤或替换。

本⽂主要以该问题设计⽅法的演变来讲解责任链设计模式。

第⼀种设计：没有任何设计模式设计了⼀个MsgProcessor类，完成字符串处理的主要⼯作。

MainClass类是本设计中的测试类。

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30public class MainClass {public static void main(String[] args) {//需要被过滤的语句String msg = "被就业了：)，敏感信息，<script>"; //实例化处理类MsgProcessor mp = new MsgProcessor(msg); String r = mp.process();System.out.println(r);}}public class MsgProcessor {private String msg;public MsgProcessor(String msg){this.msg = msg;}public String process(){String r = msg;//过滤msg中的HTML标记r = r.replace("<", "&lt;").replace(">", "&gt;");//过滤敏感词r = r.replace("敏感", "").replace("被就业", "就业"); return r;}}第⼆种设计：增加⼀个Filter接⼝在第⼀种设计中，对字符串的所有处理都放在MsgProcessor类中，扩展性极差。

通俗易懂设计模式解析——责任链模式前言今天我们介绍的是责任链模式【Chain of Responsibility Pattern】。

对于责任链模式理解起来还是比较容易的。

例如在公司请假、三天以内部门经理批准即可，但是三到七天可能就需要总监批准了、七天以上需要副总裁批准。

对于这么一个需求最初的解决方案就是if-else语句判断。

但是一旦请假的模式增加一种则需要对多重if-else进行修改，这就违背了开闭原则。

这个时候就可以采用责任链模式来解决其问题。

责任链模式为请求创建一个接收者对象的链。

这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

责任链模式介绍一、来由在软件系统中，经常会有一个请求可能会被多个对象处理。

但是每一次都是被一个对象处理。

又不能确定是哪一个对象。

如果显示指定每一个对象。

会对请求发送者和接收者造成紧耦合。

那么如何做到对请求的发送者和接收者进行解耦。

并且在运行时自行决定处理请求的对象呢？二、意图避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

三、案例四、责任链模式代码示例看上述案例图，主要涉及到两个部分：抽象处理者：定义一个处理请求的接口具体处理者：实现处理请求的接口、可以选择是自己处理或者传递给下一个接收者。

包含对下一个接收处理者的引用。

责任链模式的组成部分还是比较简单的。

我们看这么一个案例，还是用户结算时金额计算的案例。

根据用户的会员等级进行对应的折扣结算。

普通用户全额计算、普通会员95折计算、黄金会员9折计算、钻石会员7折计算：我们首先看看不使用责任链模式如何处理：namespace ChainofResponsibility_Pattern{class Program{ static void Main(string[] args){decimal Money =200M;var memberType = MemberType.GoldMember;//普通会员，95折计算if (memberType == MemberType.Member){Console.WriteLine($"普通会员，95折计算,最后金额为{Money * 0.95M}");}//黄金会员，9折计算else if(memberType == MemberType.GoldMember){Console.WriteLine($"黄金会员，9折计算,最后金额为{Money * 0.9M}");}//钻石会员，7折计算else if(memberType == MemberType.DiamondsMember){Console.WriteLine($"钻石会员，7折计算,最后金额为{Money * 0.7M}");}//无会员，全额计算else{Console.WriteLine($"无会员，全额计算,最后金额为{Money}");}}public enum MemberType{[Description("无会员")]NoMember = 1,[Description("普通会员")]Member = 2,[Description("黄金会员")]GoldMember = 3,[Description("钻石会员")]DiamondsMember = 4}}}这里我们可以看到我们使用了多个if条件判断完成的此需求（或者switch语句）。

职责链设计模式一、什么是职责链设计模式职责链设计模式（Chain of Responsibility）是一种行为设计模式，它允许多个对象按照其顺序依次处理请求，直到请求被处理或者到达链的末尾。

每个对象在收到请求后，可以选择将其处理，然后传递给下一个对象，也可以选择不处理，从而将请求传递给下一个对象。

这种模式将请求发送者和接收者解耦，使得多个对象都有可能处理请求，提高了代码的灵活性。

二、应用场景职责链设计模式通常应用于以下场景：1.处理请求的对象不确定，并且可以在运行时动态添加或删除对象。

2.需要按照特定顺序对请求进行处理。

3.请求的发送者和接收者需要解耦，避免耦合度过高。

4.想要在不明确指定接收者的情况下，动态地指定处理该请求的对象。

三、实现方式职责链设计模式的核心思想是将请求通过一个对象链传递，并让不同的对象依次处理请求。

下面是实现该模式的一般步骤：1.定义一个抽象处理器（Handler）类，其中包含一个指向下一个处理器的引用。

2.派生具体处理器（ConcreteHandler）类，实现请求处理的具体逻辑，并在需要时将请求传递给下一个处理器。

3.在客户端代码中创建处理器链的实例，并将请求发送到链的起始位置。

四、实例演示以一个账单审批系统为例，系统中有三个级别的审批者：经理、副总经理和总经理。

账单金额小于1000元的由经理审批，小于5000元的由副总经理审批，其余由总经理审批。

1. 定义抽象处理器类public abstract class Approver {protected Approver nextApprover;public void setNextApprover(Approver nextApprover) {this.nextApprover = nextApprover;}public abstract void approve(Bill bill);}2. 派生具体处理器类public class Manager extends Approver {@Overridepublic void approve(Bill bill) {if (bill.getAmount() < 1000) {System.out.println("Manager approved the bill with amount: " + bil l.getAmount());} else if (nextApprover != null) {nextApprover.approve(bill);}}}public class VicePresident extends Approver {@Overridepublic void approve(Bill bill) {if (bill.getAmount() < 5000) {System.out.println("Vice President approved the bill with amount: " + bill.getAmount());} else if (nextApprover != null) {nextApprover.approve(bill);}}}public class President extends Approver {@Overridepublic void approve(Bill bill) {System.out.println("President approved the bill with amount: " + bill. getAmount());}}3. 创建处理器链的实例并发送请求public class Main {public static void main(String[] args) {Approver manager = new Manager();Approver vicePresident = new VicePresident();Approver president = new President();manager.setNextApprover(vicePresident);vicePresident.setNextApprover(president);Bill bill1 = new Bill(800);manager.approve(bill1);Bill bill2 = new Bill(3000);manager.approve(bill2);Bill bill3 = new Bill(10000);manager.approve(bill3);}}4. 运行结果Manager approved the bill with amount: 800Vice President approved the bill with amount: 3000President approved the bill with amount: 10000五、优缺点优点：1.降低了请求发送者和接收者之间的耦合度，使得处理请求的对象可以独立变化。

C#设计模式-责任链模式⼀.介绍 责任链模式（Chain of Responsibility Pattern）。

属于⾏为型模式。

它使多个对象都有机会处理请求，从⽽避免发送者和接受者之间的耦合关系。

将这个对象连成⼀条链，并沿着这条链传递该请求，直到有⼀个对象处理它为⽌。

⼆.实现 举个例⼦，在⼀所银⾏⾥，有⼏个级别的员⼯，柜员、主管、经理。

如果有⼈来存款，柜员只能处理10000元以内的取款业务，超出了就只能传递给他的上级主管去处理。

主管只能处理100000元的业务，超出了就只能传递给他的上级经理去处理。

在使⽤责任链模式前，试⼀下⽤普通的⽅式去实现。

public static void WithDrawMoney(decimal amount){// 柜员处理if (amount < 10000){Console.WriteLine("柜员提取的⾦额");}// 主管处理else if (amount < 100000){Console.WriteLine("主管提取的⾦额");}else{Console.WriteLine("经理提取的⾦额");}} ⽤这种 if / else 的⽅式，如果新增了⼀个级别的员⼯，处理起来会很⿇烦，也违背开闭原则。

⽽且，处理业务必须从最下级开始，限制⾼级员⼯的条件，如经理就处理不了10000元以内的业务。

使⽤责任链模式可以解决这个问题。

//抽象处理者public abstract class Handler{protected Handler nextHandler;//设置下⼀级处理⼈public void SetHandler(Handler handler){this.nextHandler = handler;}public abstract void HandleRequest(decimal amount);}//柜员public class Teller : Handler{public override void HandleRequest(decimal amount){if (amount < 10000){Console.WriteLine("柜员提取的⾦额："+ amount);}else if (this.nextHandler != null){Console.WriteLine("柜员⽆法处理,转主管");nextHandler.HandleRequest(amount);}}}//主管public class Supervisor : Handler{public override void HandleRequest(decimal amount){if (amount < 100000){Console.WriteLine("主管提取的⾦额：" + amount);}else if (this.nextHandler != null){Console.WriteLine("主管⽆法处理,转经理");nextHandler.HandleRequest(amount);}}}//经理public class BankManager : Handler{public override void HandleRequest(decimal amount){Console.WriteLine("银⾏经理提取的⾦额：" + amount);}}//调⽤public static void Main(string[] args){Handler teller = new Teller();//柜员Handler supervisor = new Supervisor();//主管Handler bankManager = new BankManager();//经理teller.SetHandler(supervisor);//定义柜员上级为主管supervisor.SetHandler(bankManager);//定义主管上级为经理//Console.WriteLine("柜员处理不同⾦额的业务");Console.WriteLine("客户存9000");teller.HandleRequest(9000);Console.WriteLine();Console.WriteLine("客户存90000");teller.HandleRequest(90000);Console.WriteLine();Console.WriteLine("客户存150000");teller.HandleRequest(150000);Console.WriteLine();//Console.WriteLine("柜员请假，业务都由主管处理");Console.WriteLine("客户存9000");supervisor.HandleRequest(9000);Console.WriteLine();Console.WriteLine("客户存90000");supervisor.HandleRequest(90000);Console.WriteLine();Console.WriteLine("客户存150000");supervisor.HandleRequest(150000);Console.WriteLine();}三.总结 优点： 1.降低了请求的发送者和接受者之间的耦合。

23种设计模式：责任链模式责任链模式1.介绍概念责任链模式（Chain of Responsibility Pattern）为请求创建了⼀个接收者对象的链。

这种模式给予请求的类型，对请求的发送者和接收者进⾏解耦。

这种类型的设计模式属于⾏为型模式。

在这种模式中，通常每个接收者都包含对另⼀个接收者的引⽤。

如果⼀个对象不能处理该请求，那么它会把相同的请求传给下⼀个接收者，依此类推。

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

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

使⽤场景1、有多个对象可以处理同⼀个请求，具体哪个对象处理该请求由运⾏时刻⾃动确定。

2、在不明确指定接收者的情况下，向多个对象中的⼀个提交⼀个请求。

3、可动态指定⼀组对象处理请求。

(引⽤⾃菜鸟教程)2.实现实现步骤1.创建抽象的记录器类。

public abstract class AbstractLogger {public static int INFO = 1;public static int DEBUG = 2;public static int ERROR = 3;protected int level;//责任链中的下⼀个元素protected AbstractLogger nextLogger;public void setNextLogger(AbstractLogger nextLogger){this.nextLogger = nextLogger;}public void logMessage(int level, String message){if(this.level <= level){write(message);}if(nextLogger !=null){nextLogger.logMessage(level, message);}}abstract protected void write(String message);}2.创建扩展了该记录器类的实体类。

深⼊理解设计模式（12）：职责链模式⼀、什么是职责链模式客户端发出⼀个请求，链上的对象都有机会来处理这⼀请求，⽽客户端不需要知道谁是具体的处理对象。

这样就实现了请求者和接受者之间的解耦，并且在客户端可以实现动态的组合职责链。

使编程更有灵活性。

定义：使多个对象都有机会处理请求，从⽽避免了请求的发送者和接受者之间的耦合关系。

将这些对象连成⼀条链，并沿着这条链传递该请求，直到有对象处理它为⽌。

其过程实际上是⼀个递归调⽤。

要点主要是： 1、有多个对象共同对⼀个任务进⾏处理。

2、这些对象使⽤链式存储结构，形成⼀个链，每个对象知道⾃⼰的下⼀个对象。

3、⼀个对象对任务进⾏处理，可以添加⼀些操作后将对象传递个下⼀个任务。

也可以在此对象上结束任务的处理，并结束任务。

3、客户端负责组装链式结构，但是客户端不需要关⼼最终是谁来处理了任务。

⼆、职责链模式的结构 责任链模式涉及到的⾓⾊如下所⽰：●　抽象处理者(Handler)⾓⾊：定义出⼀个处理请求的接⼝。

如果需要，接⼝可以定义出⼀个⽅法以设定和返回对下家的引⽤。

这个⾓⾊通常由⼀个Java抽象类或者Java接⼝实现。

上图中Handler类的聚合关系给出了具体⼦类对下家的引⽤，抽象⽅法handleRequest()规范了⼦类处理请求的操作。

●　具体处理者(ConcreteHandler)⾓⾊：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

由于具体处理者持有对下家的引⽤，因此，如果需要，具体处理者可以访问下家三、职责链模式的优缺点优点：职责链模式的最主要功能就是：动态组合，请求者和接受者解耦。

请求者和接受者松散耦合：请求者不需要知道接受者，也不需要知道如何处理。

每个职责对象只负责⾃⼰的职责范围，其他的交给后继者。

各个组件间完全解耦。

动态组合职责：职责链模式会把功能分散到单独的职责对象中，然后在使⽤时动态的组合形成链，从⽽可以灵活的分配职责对象，也可以灵活的添加改变对象职责。

设计模式之责任链模式责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它将请求的发送者和接受者解耦，并且允许多个对象都有机会处理这个请求。

责任链模式通常被用于处理对象间的请求传递，使得每个对象都有机会处理请求，同时避免请求的发送者和接受者之间的耦合关系。

责任链模式由一系列的处理对象组成，每个处理对象都负责处理特定的请求，并且对下一个处理对象的引用。

当一个请求被发送时，责任链上的每个处理对象依次判断是否能处理该请求，如果能则立即处理，如果不能则传递给下一个处理对象。

这样，请求发送者并不需要知道请求最终会被哪个对象处理。

责任链模式的结构包括以下几个角色：1. 抽象处理者（Handler）：定义处理请求的接口，通常包含一个指向下一个处理者的引用。

2. 具体处理者（ConcreteHandler）：实现抽象处理者的接口，具体处理请求的逻辑，并且可根据需要传递请求给下一个处理者。

下面通过一个实际的例子来说明责任链模式的应用。

假如在一个电商系统中，有三个订单处理的环节：商品审核、支付检查和库存验证。

货物在途过程中，可能会出现商品信息不完整、支付异常或库存不足的情况。

我们可以使用责任链模式来设计这样一个订单处理系统。

首先，定义一个抽象处理者（Handler）接口，包含一个处理请求的方法，并且可以设置下一个处理者的引用。

```javapublic interface Handler {void setNextHandler(Handler handler);void handleRequest(Order order);}```然后，实现具体的处理者（ConcreteHandler）类，包括商品审核处理者、支付检查处理者和库存验证处理者。

每个具体处理者都实现了处理请求的方法，并且根据需要判断是否需要传递请求给下一个处理者。

```javapublic class ProductCheckHandler implements Handler {private Handler nextHandler;@Overridepublic void setNextHandler(Handler handler) {this.nextHandler = handler;}@Overridepublic void handleRequest(Order order) {// 商品审核逻辑// ...// 如果有下一个处理者，则传递请求if (nextHandler != null) {nextHandler.handleRequest(order);}}}public class PaymentCheckHandler implements Handler { private Handler nextHandler;@Overridepublic void setNextHandler(Handler handler) {this.nextHandler = handler;}@Overridepublic void handleRequest(Order order) {// 支付检查逻辑// ...// 如果有下一个处理者，则传递请求if (nextHandler != null) {nextHandler.handleRequest(order);}}}public class StockCheckHandler implements Handler { private Handler nextHandler;@Overridepublic void setNextHandler(Handler handler) {this.nextHandler = handler;}@Overridepublic void handleRequest(Order order) {// 库存验证逻辑// ...// 如果有下一个处理者，则传递请求if (nextHandler != null) {nextHandler.handleRequest(order);}}}```最后，在客户端代码中组装责任链，并将请求发送给第一个处理者。

【设计模式】责任链模式使⽤频率：★★★☆☆⼀、什么是责任链模式为请求创建了⼀个接收者对象的链，每个接收者都包含对另⼀个接收者的引⽤，当某个接受者不能处理该请求时，会将该请求转给下⼀个接受者处理；⼆、补充说明请求发送者与请求接受者解耦应⽤例⼦：struts的拦截器，servlet的过滤器三、⾓⾊抽象请求处理者具体请求处理者：包含下⼀个具体请求处理者的引⽤客户端：请求发送者四、例⼦，JA VA实现说明：模拟⼀个村、镇、县的责任链关系请求抽象处理者package com.pichen.dp.behavioralpattern.chain;public abstract class Handler {protected Handler next;public abstract void handleRequest(String value);public Handler next() {return this.next;}public void setNext(Handler next) {this.next = next;}}具体村、镇、县处理者package com.pichen.dp.behavioralpattern.chain;public class VillageHandler extends Handler {/*** @see com.pichen.dp.behavioralpattern.chain.Handler#handleRequest()*/@Overridepublic void handleRequest(String value) {if ("village".equals(value)) {System.out.println("VillageHandler: handled~");} else {System.out.println("VillageHandler: pass~");this.next.handleRequest(value);}}}package com.pichen.dp.behavioralpattern.chain;public class TownHandler extends Handler {@Overridepublic void handleRequest(String value) {if ("town".equals(value)) {System.out.println("VillageHandler: handled~");} else {System.out.println("Town: pass~");this.next.handleRequest(value);}}}package com.pichen.dp.behavioralpattern.chain;public class CountyHandler extends Handler {@Overridepublic void handleRequest(String value) {if ("county".equals(value)) {System.out.println("County: handled~");} else if (this.next == null) {System.out.println("no next Handler, this request can not be handle~"); } else {System.out.println("County: pass~");this.next.handleRequest(value);}}}客户端：package com.pichen.dp.behavioralpattern.chain;public class Main {public static void main(String[] args) {Handler villageHandler = new VillageHandler();Handler townHandler = new TownHandler();Handler countyHandler = new CountyHandler();villageHandler.setNext(townHandler);townHandler.setNext(countyHandler);System.out.println("test county request:");villageHandler.handleRequest("county");System.out.println("\ntest city request:");villageHandler.handleRequest("city");}}结果：test county request:VillageHandler: pass~Town: pass~County: handled~test city request:VillageHandler: pass~Town: pass~no next Handler, this request can not be handle~。

设计模式：责任链模式设计模式：责任链模式⼀、前⾔责任链（chain of responsibility）模式很像异常的捕获和处理，当⼀个问题发⽣的时候，当前对象看⼀下⾃⼰是否能够处理，不能的话将问题抛给⾃⼰的上级去处理，但是要注意这⾥的上级不⼀定指的是继承关系的⽗类，这点和异常的处理是不⼀样的。

所以可以这样说，当问题不能解决的时候，将问题交给另⼀个对象去处理，就这样⼀直传递下去直⾄当前对象找不到下线了，处理结束。

如下图所⽰，处于同等层次的类都继承⾃Support类，当当前对象不能处理的时候，会根据预先设定好的传递关系将问题交给下⼀个⼈，可以说是“近⽔楼台先得⽉”，就看有没有能⼒了。

我们也可以看作是⼤家在玩⼀个传谜语猜谜底的⼩游戏，按照座位的次序以及规定的顺序传递，如果⼀个⼈能回答的上来游戏就结束，否则继续向下传，如果所有⼈都回答不出来也会结束。

这样或许才是责任链的本质，体现出了同等级的概念。

⼆、代码Trouble 类：（数据结构）1package zyr.dp.cor;23public class Trouble {45private int number;6public Trouble( int number){7this.number=number;8 }9public int getNumber() {10return number;11 }12public String toString(){13return "问题编号：["+number+"]";14 }15 }Support 类：（抽象类，使⽤了模板⽅法）1package zyr.dp.cor;23public abstract class Support {45protected abstract boolean resolve(Trouble trouble); 67 String name;8 Support next;910public Support(String name){=name;12 }1314public String toString() {15return "对象：<"+name+">";16 }1718public Support setAndReturnNext(Support next){19this.next=next;20return next;21 }2223public final void support(Trouble trouble){24if(resolve(trouble)){25 done(trouble);26 }else if(next!=null){27 next.support(trouble);28 }else{29 fail(trouble);30 }31 }3233protected void fail(Trouble trouble) {34 System.out.println(this+"解决问题失败，"+trouble);35 }3637protected void done(Trouble trouble) {38 System.out.println(this+"已经解决问题，"+trouble);39 }4041 }NoSupport 类：1package zyr.dp.cor;23public class NoSupport extends Support {45public NoSupport(String name) {6super(name);7 }89protected boolean resolve(Trouble trouble) {10return false;11 }1213 }OddSupport 类：1package zyr.dp.cor;23public class OddSupport extends Support {45public OddSupport(String name) {6super(name);7 }89protected boolean resolve(Trouble trouble) {10return (trouble.getNumber()%2) == 1 ? true : false;11 }1213 }SpecialSupport 类：1package zyr.dp.cor;23public class SpecialSupport extends Support {45public int specialNumber;6public SpecialSupport(String name,int specialNumber) {7super(name);8this.specialNumber= specialNumber;9 }1011protected boolean resolve(Trouble trouble) {12return trouble.getNumber()==specialNumber ? true : false;13 }1415 }LimitSupport 类：1package zyr.dp.cor;23public class LimitSupport extends Support {45private int limit;6public LimitSupport(String name,int limit) {7super(name);8this.limit=limit;9 }1011protected boolean resolve(Trouble trouble) {12return trouble.getNumber()<=limit? true : false;13 }1415 }Main类：1package zyr.dp.cor;23public class Main {45public static void main(String[] args) {6 Support limitSupportLess = new LimitSupport("有限⽀持⼩",5);7 Support limitSupportMore = new LimitSupport("有限⽀持⼤",15);8 Support oddSupport = new OddSupport("奇数⽀持");9 Support specialSupport = new SpecialSupport("特定⽀持",36);10 Support noSupport = new NoSupport("没有⽀持");11 limitSupportLess.setAndReturnNext(limitSupportMore).setAndReturnNext(oddSupport).setAndReturnNext(specialSupport).setAndReturnNext(noSupport);12 System.out.println("===<有限⽀持⼩>尝试解决问题===");13for(int i=0;i<40;i++){14 limitSupportLess.support(new Trouble(i));15 }16 System.out.println("===<特定⽀持>尝试解决问题===");17for(int i=0;i<40;i++){18 specialSupport.support(new Trouble(i));19 }2021 }2223 }运⾏结果：1 ===<有限⽀持⼩>尝试解决问题===2对象：<有限⽀持⼩>已经解决问题，问题编号：[0]3对象：<有限⽀持⼩>已经解决问题，问题编号：[1]4对象：<有限⽀持⼩>已经解决问题，问题编号：[2]5对象：<有限⽀持⼩>已经解决问题，问题编号：[3]6对象：<有限⽀持⼩>已经解决问题，问题编号：[4]7对象：<有限⽀持⼩>已经解决问题，问题编号：[5]8对象：<有限⽀持⼤>已经解决问题，问题编号：[6]9对象：<有限⽀持⼤>已经解决问题，问题编号：[7]10对象：<有限⽀持⼤>已经解决问题，问题编号：[8]10对象：<有限⽀持⼤>已经解决问题，问题编号：[8]11对象：<有限⽀持⼤>已经解决问题，问题编号：[9]12对象：<有限⽀持⼤>已经解决问题，问题编号：[10]13对象：<有限⽀持⼤>已经解决问题，问题编号：[11]14对象：<有限⽀持⼤>已经解决问题，问题编号：[12]15对象：<有限⽀持⼤>已经解决问题，问题编号：[13]16对象：<有限⽀持⼤>已经解决问题，问题编号：[14]17对象：<有限⽀持⼤>已经解决问题，问题编号：[15]18对象：<没有⽀持>解决问题失败，问题编号：[16]19对象：<奇数⽀持>已经解决问题，问题编号：[17]20对象：<没有⽀持>解决问题失败，问题编号：[18]21对象：<奇数⽀持>已经解决问题，问题编号：[19]22对象：<没有⽀持>解决问题失败，问题编号：[20]23对象：<奇数⽀持>已经解决问题，问题编号：[21]24对象：<没有⽀持>解决问题失败，问题编号：[22]25对象：<奇数⽀持>已经解决问题，问题编号：[23]26对象：<没有⽀持>解决问题失败，问题编号：[24]27对象：<奇数⽀持>已经解决问题，问题编号：[25]28对象：<没有⽀持>解决问题失败，问题编号：[26]29对象：<奇数⽀持>已经解决问题，问题编号：[27]30对象：<没有⽀持>解决问题失败，问题编号：[28]31对象：<奇数⽀持>已经解决问题，问题编号：[29]32对象：<没有⽀持>解决问题失败，问题编号：[30]33对象：<奇数⽀持>已经解决问题，问题编号：[31]34对象：<没有⽀持>解决问题失败，问题编号：[32]35对象：<奇数⽀持>已经解决问题，问题编号：[33]36对象：<没有⽀持>解决问题失败，问题编号：[34]37对象：<奇数⽀持>已经解决问题，问题编号：[35]38对象：<特定⽀持>已经解决问题，问题编号：[36]39对象：<奇数⽀持>已经解决问题，问题编号：[37]40对象：<没有⽀持>解决问题失败，问题编号：[38]41对象：<奇数⽀持>已经解决问题，问题编号：[39]42 ===<特定⽀持>尝试解决问题===43对象：<没有⽀持>解决问题失败，问题编号：[0]44对象：<没有⽀持>解决问题失败，问题编号：[1]45对象：<没有⽀持>解决问题失败，问题编号：[2]46对象：<没有⽀持>解决问题失败，问题编号：[3]47对象：<没有⽀持>解决问题失败，问题编号：[4]48对象：<没有⽀持>解决问题失败，问题编号：[5]49对象：<没有⽀持>解决问题失败，问题编号：[6]50对象：<没有⽀持>解决问题失败，问题编号：[7]51对象：<没有⽀持>解决问题失败，问题编号：[8]52对象：<没有⽀持>解决问题失败，问题编号：[9]53对象：<没有⽀持>解决问题失败，问题编号：[10]54对象：<没有⽀持>解决问题失败，问题编号：[11]55对象：<没有⽀持>解决问题失败，问题编号：[12]56对象：<没有⽀持>解决问题失败，问题编号：[13]57对象：<没有⽀持>解决问题失败，问题编号：[14]58对象：<没有⽀持>解决问题失败，问题编号：[15]59对象：<没有⽀持>解决问题失败，问题编号：[16]60对象：<没有⽀持>解决问题失败，问题编号：[17]61对象：<没有⽀持>解决问题失败，问题编号：[18]62对象：<没有⽀持>解决问题失败，问题编号：[19]63对象：<没有⽀持>解决问题失败，问题编号：[20]64对象：<没有⽀持>解决问题失败，问题编号：[21]65对象：<没有⽀持>解决问题失败，问题编号：[22]66对象：<没有⽀持>解决问题失败，问题编号：[23]67对象：<没有⽀持>解决问题失败，问题编号：[24]68对象：<没有⽀持>解决问题失败，问题编号：[25]69对象：<没有⽀持>解决问题失败，问题编号：[26]70对象：<没有⽀持>解决问题失败，问题编号：[27]71对象：<没有⽀持>解决问题失败，问题编号：[28]72对象：<没有⽀持>解决问题失败，问题编号：[29]73对象：<没有⽀持>解决问题失败，问题编号：[30]74对象：<没有⽀持>解决问题失败，问题编号：[31]75对象：<没有⽀持>解决问题失败，问题编号：[32]76对象：<没有⽀持>解决问题失败，问题编号：[33]77对象：<没有⽀持>解决问题失败，问题编号：[34]78对象：<没有⽀持>解决问题失败，问题编号：[35]79对象：<特定⽀持>已经解决问题，问题编号：[36]80对象：<没有⽀持>解决问题失败，问题编号：[37]81对象：<没有⽀持>解决问题失败，问题编号：[38]82对象：<没有⽀持>解决问题失败，问题编号：[39]运⾏结果我们可以看到同等级的对象，按照⾃⼰被添加的次序来安排，这点⾮常重要，在实际应⽤中，我们都是将解答能⼒最弱的类放到最前⾯，然后⼀点点加强，这样可以使得解答能⼒⽐较弱的类有机会去解答，正如我们的例⼦，如果让解答能⼒强的类直接去处理问题，能够处理就不回传给下⼀个了，当然我们也看到这⾥⾯有的类能⼒有限，有的类和其他类的能⼒有重叠部分，当然也有所有类都解决不了的问题。

C#设计模式（21）——责任链模式⼀、引⾔ 在现实⽣活中，有很多请求并不是⼀个⼈说了就算的，例如⾯试时的⼯资，低于1万的薪⽔可能技术经理就可以决定了，但是1万~1万5的薪⽔可能技术经理就没这个权利批准，可能就需要请求技术总监的批准，所以在⾯试的完后，经常会有⾯试官说，你这个薪⽔我这边觉得你这技术可以拿这个薪⽔的，但是还需要技术总监的批准等的话。

这个例⼦也就诠释了本⽂要介绍的内容。

⽣活中的这个例⼦真是应⽤了责任链模式。

2.1 责任链模式的定义 从⽣活中的例⼦可以发现，某个请求可能需要⼏个⼈的审批，即使技术经理审批完了，还需要上⼀级的审批。

这样的例⼦，还有公司中的请假，少于3天的，直属Leader就可以批准，3天到7天之内就需要项⽬经理批准，多余7天的就需要技术总监的批准了。

介绍了这么多⽣活中责任链模式的例⼦的，下⾯具体给出⾯向对象中责任链模式的定义。

责任链模式指的是——某个请求需要多个对象进⾏处理，从⽽避免请求的发送者和接收之间的耦合关系。

将这些对象连成⼀条链⼦，并沿着这条链⼦传递该请求，直到有对象处理它为⽌。

2.2 从责任链模式的定义可以发现，责任链模式涉及的对象只有处理者⾓⾊，但由于有多个处理者，它们具有共同的处理请求的⽅法，所以这⾥抽象出⼀个抽象处理者⾓⾊进⾏代码复⽤。

这样分析下来，责任链模式的结构图也就不⾔⽽喻了，具体结构图如下所⽰。

主要涉及两个⾓⾊：抽象处理者⾓⾊（Handler）：定义出⼀个处理请求的接⼝。

这个接⼝通常由接⼝或抽象类来实现。

具体处理者⾓⾊（ConcreteHandler）：具体处理者接受到请求后，可以选择将该请求处理掉，或者将请求传给下⼀个处理者。

因此，每个具体处理者需要保存下⼀个处理者的引⽤，以便把请求传递下去。

2.3 责任链模式的实现 有了上⾯的介绍，下⾯以公司采购东西为例⼦来实现责任链模式。

公司规定，采购架构总价在1万之内，经理级别的⼈批准即可，总价⼤于1万⼩于2万5的则还需要副总进⾏批准，总价⼤于2万5⼩于10万的需要还需要总经理批准，⽽⼤于总价⼤于10万的则需要组织⼀个会议进⾏讨论。