责任链设计模式
责任链设计模式（过滤器、拦截器）
责任链设计模式（过滤器、拦截器）责任链设计模式（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("<", "<").replace(">", ">");//过滤敏感词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#设计模式-责任链模式
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种设计模式：责任链模式
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）：职责链模式
深⼊理解设计模式（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~。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1. 责任链模式
过滤器就是责任链模式的一种应用
链条式处理
2. 在一个filterChain 中添加另一条filterChain ，filterChain 本身也可看作是filter ，让其继承
filter 接口
3. 处理双向链条，及处理过去了的有处理回来的。
（在过滤器和struts 的拦截器中都是这样
处理的）
4.
就是在doFIlter 方法中让其得到filterChain 的引用 ，核心代码是：
package com.xk.test_responsibility;
import java.util.ArrayList;
public class FilterChain implements Filter {
public int index = 0;
public ArrayList<Filter> arrayList = new ArrayList<Filter>();
public FilterChain addFilter(Filter filter) {
this .arrayList
.add(filter);
return this;
}
public void doFilter(Request request , Response response , FilterChain filterChain) {
if(arrayList.size() == index) {
return;
}
Filter filter = arrayList.get(index);
index++;
filter.doFilter(request, response, filterChain);
}
}
package com.xk.test_responsibility;
import com.xk.test_responsibility.Filter;
public class HtmlFilter implements Filter {
public void doFilter(Request request , Response response , FilterChain filterChain) {
request.requestStr = request.requestStr.replaceAll("<", "[").replace(">", "]");
filterChain.doFilter(request, response, filterChain);
response.responseStr += "-------->HTMLFilter";
}
}
这个有点像是递归的调用。