实验五：责任链模式

合集下载

通俗易懂设计模式解析——责任链模式

通俗易懂设计模式解析——责任链模式前言今天我们介绍的是责任链模式【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语句）。

枚举责任链模式

枚举责任链模式全文共四篇示例，供读者参考第一篇示例：责任链模式是一种行为设计模式，它允许一系列对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合。

这种模式中，请求会沿着一个链条传递，直到有一个对象处理它为止。

这种模式可以提供更大的灵活性和降低耦合度。

在责任链模式中，通常会有一个处理请求的接口，每个处理器都会实现这个接口。

当一个请求到来时，它会先传递给第一个处理器，如果第一个处理器没有处理它，那么它会被传递给下一个处理器，直到有一个处理器能够处理这个请求。

枚举责任链模式是责任链模式的一种变体。

在枚举责任链模式中，责任链中的处理器是固定的，而且它们的顺序是事先确定的。

这种模式适用于处理固定数量的请求，并且每个请求都有固定的处理流程。

枚举责任链模式通常通过枚举类型实现，每个枚举值代表一个处理器。

这样可以保证责任链中的处理器是固定的，不会随意增加或删除。

通过枚举类型可以确保责任链中的处理器的执行顺序是固定的。

枚举责任链模式在实际项目中有着广泛的应用。

比如在电商系统中，订单的处理流程是一个典型的责任链模式。

订单在提交后，需要经过一系列处理，比如订单校验、库存检查、支付处理等。

这些处理流程就可以通过枚举责任链模式来实现。

另一个应用场景是在权限控制系统中。

不同的用户可能有不同的权限，而权限控制系统可以通过责任链模式来实现。

每个处理器代表一种权限级别，请求会依次传递给不同的处理器，直到找到一个能够处理该请求的处理器为止。

枚举责任链模式是一种简单而有效的设计模式，它可以帮助我们实现复杂的处理流程，降低组件之间的耦合度，提高系统的灵活性和可维护性。

在实际项目中，我们可以根据具体情况选择是否使用枚举责任链模式来实现系统的功能。

第二篇示例：枚举责任链模式是一种设计模式，它主要用于解决对象之间的关系及其行为的问题。

在这种模式中，每个对象都有一个自己的责任，并对其自己的责任负责。

如果这个对象无法处理这个责任，它将把责任传递给下一个对象，直到责任被处理为止。

责任链模式

处理请求(续)
现在具体的handler看上去如下： public class ConcreteHandler implements Handler { private Handler successor; public ConcreteHandler(Handler successor) { this.successor = successor; } public void handleRequest(String request) { if (request.equals("Help")) { // We handle help ourselves, so help code is here. } else // Pass it on! successor.handle(request); } }
责任链模式例1 (续)
下面是典型的Java 1.0 AWT 时间处理程序：
public boolean action(Event event, Object obj) { if (event.target == test_button) doTestButtonAction(); else if (event.target == exit_button) doExitButtonAction(); else return super.action(event,obj); return true; // Return true to indicate the event has // been handled and should not be propagated // further. }
责任链模式例1 (续)
Java 1.1 AWT 事件模型使用观察者模式。想要处理事件的对象注册为组件的事件监听器。当事件发生时，它被指派给组件。然后组件将该事件分派给它的任意一个监听器。如果组件没有监听器，该事件就被放弃。对该应用来说，观察者模式的效率更高也更灵活！

责任链模式——精选推荐

责任链模式责任链模式责任链模式：使多个对象都有机会处理请求，从⽽避免了请求的发送者和接收者之间的耦合关系。

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

责任链模式的重点在“链”，由抽象类中的⽅法决定由那个实现类处理该请求，并返回结果，其通⽤类图如下：抽象的处理者Handler实现三个职责：⼀个是定义⼀个请求的处理⽅法handleRequest()，唯⼀对外开放的⽅法；⼀个是定义⼀个链的编排⽅法setLevel()，即处理请求的先后顺序，还有设置和获取当前类的处理等级；第三个是定义了具体的请求者必须实现的具体处理任务response()。

通⽤类图的源码如下：public class Request {//定义当前请求的处理等级private int level;public Request(){this.level = 1; //默认处理等级为1}public void setLevel(int level){this.level = level;}public int getLevel(){return this.level;}}public abstract class Handler {private Handler nextHandler;private int level;protected void setNextHanlder(Handler handler){this.nextHandler = handler;}//模板⽅法,判断请求级别和当前处理的级别public final String handlerRequest(Request request){if(request.getLevel() == this.level)return response(request);else{if(this.nextHandler != null)return this.nextHandler.handlerRequest(request);elsereturn "请求处理失败";}}protected int getLevel(){return this.level;}protected void setLevel(int level){this.level = level;}//抽象处理⽅法，具体在⼦类中实现protected abstract String response(Request request);}public class ConcreteHandler1 extends Handler{@Overrideprotected String response(Request request) {// TODO Auto-generated method stubreturn "第⼀个处理者处理请求";}}public class ConcreteHandler2 extends Handler{@Overrideprotected String response(Request request) {// TODO Auto-generated method stubreturn "第⼆个处理者处理请求";}}public class Client {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubRequest request = new Request();//request.setLevel(3);Handler handler1 = new ConcreteHandler1();Handler handler2 = new ConcreteHandler2();handler1.setLevel(1);handler2.setLevel(2);handler1.setNextHanlder(handler2);System.out.println(handler1.handlerRequest(request));}}优点：责任链模式的优点是将请求和处理分开，请求者可以不⽤知道谁去处理，处理者不⽤知道请求的全貌，两者解耦，提⾼系统灵活性。

职责链设计模式

职责链设计模式一、什么是职责链设计模式职责链设计模式（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.降低了请求发送者和接收者之间的耦合度，使得处理请求的对象可以独立变化。

责任链模式（ChainofResponsibilityPattern）

责任链模式（ChainofResponsibilityPattern）责任链模式是一种对象的行为模式。

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。

请求在这个链上传递，直到链上的某一个对象决定处理此请求。

发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使系统可以在不影响客户端的情况下动态的重新组织链和分配责任。

一、责任链模式的结构1、责任链模式涉及的角色抽象处理者角色（Handler）：定义出一个处理请求的接口。

如果需要，接口可以定义出一个方法，以设定和返回下家的引用。

这个角色通常由一个Java抽象类或Java接口实现。

图中的聚合关系给出了具体子类对下家的引用，抽象方法handlerRequest（）规范了子类处理请求的操作。

具体处理者角色（ConcreteHandler）：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

由于处理者持有下家引用，因此，如果需要，具体处理者可以访问下家。

抽象处理者角色public abstract class Handler{protected Handler successor;//定义下家的引用public abstract void handleRequest();//处理方法，调用此方法处理请求public void setSuccessor(Handler successor)//赋值方法，调用此方法设置下家{this.successor = successor;}public Handler getSuccessor()//取值方法，得到下家对象{return successor;}}具体处理者角色，如果有下家，就将请求传给下家，否则就处理请求public class ConcreteHandler extends Handler{public void handleRequest(){if (getSuccessor() != null){System.out.println("The request is passed to " + getSuccessor());getSuccessor().handleRequest();}else{System.out.println("The request is handled here.");}}}客户端角色public class Client{static private Handler handler1, handler2;public static void main(String[] args){handler1 = new ConcreteHandler();handler2 = new ConcreteHandler();handler1.setSuccessor(handler2);handler1.handleRequest();}}客户端创建了2个处理者对象，并指定第一个处理者对象的下家是第2个处理者对象，而第2个处理者对象没有下家。

职责链模式

Console.Read(); }
模式实例与解析
处理完成
校长
系主任
隐藏
院长
节点缺失怎么办？
辅导员学生
模式实例与解析
static void Main(string[] args) { CommonManager xiaozhang = new CommonManager("校长"); //Majordomo yuanzhang= new Majordomo("院长"); GeneralManager fudaoyuan= new GeneralManager("辅导员"); fudaoyuan.SetSuperior(xiaozhang); //yuanzhnag.SetSuperior(xiaozhang); Request request = new Request(); request.RequestType = "请假"; request.RequestContent = "薛雅婷请假"; request.Number = 1; fudaoyuan.RequestApplications(request);
一个请求可以最终不被任何接收端对象所接收。
模式效果与应用
• 纯与不纯的职责链模式
– 一个纯的职责链模式要求一个具体处理者对象只能在
两个行为中选择一个：一个是承担责任，另一个是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又将责任向下传的情况。 – 在一个纯的职责链模式里面，一个请求必须被某一个
处理者对象所接收；在一个不纯的职责链模式里面，
一个具体处理者 +HandleRequest()

责任链模式和观察者模式

责任链模式和观察者模式责任链模式顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了⼀个接收者对象的链。

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

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

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

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

介绍意图：避免请求发送者和接收者耦合在⼀起，让多个对象都有可能接收请求，将这些对象连接成⼀条链，并且沿着这条链传递请求，直到有对象处理他为⽌。

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

何时使⽤：在处理消息的时候以过滤很多道。

如何解决：拦截的类都实现统⼀接⼝。

应⽤实例： 1、红楼梦中的"击⿎传花"。

2、JS 中的事件冒泡。

3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

优点： 1、降低耦合度。

它将请求的发送者和接收者解耦。

2、简化了对象。

使得对象不需要知道链的结构。

3、增强给对象指派职责的灵活性。

通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4、增加新的请求处理类很⽅便。

缺点： 1、不能保证请求⼀定被接收。

2、系统性能将受到⼀定影响，⽽且在进⾏代码调试时不太⽅便，可能会造成循环调⽤。

3、可能不容易观察运⾏时的特征，有碍于除错。

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

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

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

注意事项：在 JAVA WEB 中遇到很多应⽤。

观察者模式当对象间存在⼀对多关系时，则使⽤观察者模式（Observer Pattern）。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验5：责任链模式一、实验目的本实验要求学生掌握责任链模式，要求学生理解责任链模式中的二种角色并完成类的定义及测试。

二、实验任务1．计算整数的阶乘。

要求在计算阶乘时综合考虑计算速度与内存占用多少，使用责任链模式分析有哪些类以及这些类的角色，完成这些类的定义并分别测试每一种处理情况。

答：处理者（Handler）角色：类Handler具体处理者（ConcreteHandler）角色：类UseInt、类UseLong、类UseBigInteger（1）处理者（Handler）public interface Handler {public void handleRequest(String str);public void setNextHandler(Handler handler);}（2）具体处理者（ConcreteHandler）public class UseInt implements Handler{private Handler handler;private int result = 1;public void handleRequest(String str){try{int n=(str);int i=1;while(i<=n){result = result*i;if(result<=0){"超出我的能力范围，我计算不了");return ;}i++;}"的阶乘："+result+"\n");}catch (NumberFormatException exp) {}}public void setNextHandler(Handler handler){=handler;}}public class UseLong implements Handler {private Handler handler;long result=1;public void handleRequest(String str){try{int i=1;long n=(str);while(i<=n){result=result*i;if(result<=0){"超出我的能力范围，我计算不了");(str);}i++;}"的阶乘："+result+"\n");}catch(NumberFormatException exp){}}public void setNextHandler(Handler handler){ =handler;}}public class UseBigInteger implements Handler{ private Handler handler;private BigInteger result = new BigInteger("1");public void handleRequest(String str){BigInteger n = new BigInteger(str);BigInteger ONE = new BigInteger("1");BigInteger i = ONE;while(n)<=0){result=(i);i=(ONE);}"的阶乘："+result+"\n");}public void setNextHandler(Handler handler){=handler;}}（3）测试类：public class Test {private Handler useInt,useLong,useBigInteger; public void createChain(){useInt = new UseInt();useLong = new UseLong();useBigInteger = new UseBigInteger();(useLong);(useBigInteger);}public void responseClient(String str){"计算"+str+"的阶乘");(str);}public static void main(String[] args) {Test test=new Test();();("10");("20");("32");}}运行截图如下：2．采购审批往往是分级进行的，其常常根据采购金额的不同由不同层次的主管人员来审批。

例如，主任可以审批5万元以下（不包括5万元）的采购单，副董事长可以审批5万元至10 万元（不包括10万元）的采购单，董事长可以审批10万元至50万元（不包括50 万元）的采购单，50 万元及以上的采购单就需要开董事会讨论决定。

使用责任链模式分析有哪些类以及这些类的角色，完成这些类的定义并分别测试每一种处理情况。

答：处理者（Handler）角色：类Handler具体处理者（ConcreteHandler）角色：类、类Vice_president、类President、类Meetting（1）处理者（Handler）public interface Handler {public void handleRequest(String str);public void setNextHandler(Handler handler);}（2）具体处理者（ConcreteHandler）public class ChairMan implements Handler{Handler handler;public void requestHandle(String str){try{long money = (str);if(money<50000){"主任审批"+money+"元");}else{"元"+"超出主任范畴");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){=handler;}}class Vice_president implements Handler{Handler handler;public void requestHandle(String str){try{long money=(str);if(money>=50000&&money<100000){"副董事长审批"+money+"元");}else{"元"+"超出副董事长范畴");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){=handler;}}class President implements Handler{Handler handler;public void requestHandle(String str){try{long money=(str);if(money>=100000&&money<500000){"董事长审批"+money+"元");}else{"元"+"超出董事长范畴");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){ =handler;}}class Meetting implements Handler{Handler handler;public void requestHandle(String str){try{BigInteger money=new BigInteger(str);if(new BigInteger("500000"))>=0){"会议审批"+money+"元");}}catch(Exception e){}}public void setNextHandler(Handler handler){ =handler;}}（3）测试类：public class Test {ChairMan chairman;Vice_president vice_president; President president;Meetting meetting;public void createChine(){chairman= new ChairMan();vice_president = new Vice_president();president = new President();meetting = new Meetting ();(vice_president);(president);(meetting);}public void setClientRequest(String str){ "采购金额:"+str+"元");(str);}public static void main(String[] args) {Test test = new Test();();("6000");("60000");("110000");("6000000");}}运行截图如下：3．公司请假审批流程如下：如果请假小于3天只需要项目经理批复就行；如果请假大于等于3天，小于7天需要人事经理批复；如果请假大于等于7天，小于15天需要总经理批复；如果申请请假大于等于15天，决绝批复。

使用责任链模式分析有哪些类以及这些类的角色，完成这些类的定义并分别测试每一种处理情况。

答：处理者（Handler）角色：类Handler具体处理者（ConcreteHandler）角色：类Project_Manager、类Personel_Manager、类Top_Manager、类Meetting（1）处理者（Handler）public interface Handler {public void handleRequest(String str);public void setNextHandler(Handler handler);}（2）具体处理者（ConcreteHandler）public class Project_Manager implements Handler{Handler handler;public void requestHandle(String str){try{int day=(str);if(day<3){"项目经理批复\n");}else{"超出项目经理职权");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){ =handler;}}public class Personel_Manager implements Handler{ Handler handler;public void requestHandle(String str){try{int day=(str);if(day>=3&&day<7){"人事经理批复\n");}else{"超出人事经理职权");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){ =handler;}}public class Top_Manager implements Handler{ Handler handler;public void requestHandle(String str){try{int day=(str);if(day>=7&&day<15){"总经理批复\n");}else{"总经理考虑");(str);}}catch(Exception e){}}public void setNextHandler(Handler handler){ =handler;}}public class Meetting implements Handler{Handler handler;public void requestHandle(String str){try{int day=(str);if(day>=15){"决绝批复\n");}}catch(Exception e){}}public void setNextHandler(Handler handler){=handler;}}（3）测试类：public class Test {Project_Manager projectmanager;Personel_Manager personelmanager;Top_Manager topmanager;Meetting meetting;public void createChine(){projectmanager= new Project_Manager();personelmanager = new Personel_Manager();topmanager = new Top_Manager();meetting = new Meetting ();(personelmanager);(topmanager);(meetting);}public void setClientRequest(String str){"请假"+str+"天");(str);}public static void main(String[] args) {Test test = new Test();();("2");("4");("8");("16");}}运行截图如下：。