软件体系结构与设计模式第十章 责任链模式

合集下载

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

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

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

设计模式之职责链模式

设计模式之职责链模式

private int number; private double amount; private string purpose; // Constructors public PurchaseRequest(int number, double amount, string purpose) { this.number = number; this.amount = amount; this.purpose = purpose; } // Properties public double Amount { get { return amount; } set { amount = value; } } public string Purpose { get { return purpose; } set { purpose = value; } } public int Number { get { return number; } set { number = value; } } } /**/ /// <summary> /// ChainApp Application /// </summary> public class ChainApp { public static void Main(string[] args) { // Setup Chain of Responsibility Director Larry = new Director("Larry"); VicePresident Sam = new VicePresident("Sam");
if (successor != null) successor.ProcessRequest(request); } } // "ConcreteHandler" class VicePresident : Approver { // Constructors public VicePresident(string name) : base(name) { } // Methods override public void ProcessRequest(PurchaseRequest request) { if (request.Amount < 25000.0) Console.WriteLine("{0} {1} approved request# {2}", this, name, request.Number); else if (successor != null) successor.ProcessRequest(request); } } // "ConcreteHandler" class President : Approver { // Constructors public President(string name) : base(name) { } // Methods override public void ProcessRequest(PurchaseRequest request) { if (request.Amount < 100000.0) Console.WriteLine("{0} {1} approved request# {2}", this, name, request.Number); else Console.WriteLine("Request# {0} requires " + "an executive meeting!", request.Number); } } // Request details class PurchaseRequest { // Member Fields

责任链模式(Chain of Responsibility)

责任链模式(Chain of Responsibility)

责任链模式(Chain of Responsibility)责任链模式,有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。

但是发出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。

先看看关系图:Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。

[java]view plaincopy1.public interface Handler {2.public void operator();3.}[java]view plaincopy1.public abstract class AbstractHandler {2.3.private Handler handler;4.5.public Handler getHandler() {6.return handler;7. }8.9.public void setHandler(Handler handler) {10.this.handler = handler;11. }12.13.}[java]view plaincopy1.public class MyHandler extends AbstractHandler implements Handler {2.3.private String name;4.5.public MyHandler(String name) { = name;7. }8.9.@Override10.public void operator() {11. System.out.println(name+"deal!");12.if(getHandler()!=null){13. getHandler().operator();14. }15. }16.}[java]view plaincopy1.public class Test {2.3.public static void main(String[] args) {4. MyHandler h1 = new MyHandler("h1");5. MyHandler h2 = new MyHandler("h2");6. MyHandler h3 = new MyHandler("h3");7.8. h1.setHandler(h2);9. h2.setHandler(h3);10.11. h1.operator();12. }13.}输出:h1deal!h2deal!h3deal!此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。

设计模式之职责链模式

设计模式之职责链模式

设计模式之职责链模式 相信⼤家都玩过类似于“⽃地主”的纸牌游戏,某⼈出牌给他的下家,下家看看⼿中的牌,如果要不起,则将出牌请求转发给他的下家,其下家再进⾏判断。

⼀个循环下来,如果其他⼈都要不起该牌,则最初的出牌者可以打出新牌。

在这个过程中,纸牌作为⼀个请求沿着⼀条链在传递,每⼀位纸牌的玩家都可以处理该请求。

在设计模式中,也有⼀种专门⽤于处理这种请求链式的模式,它就是职责链模式。

⼀职责链模式概述1.1 职责链模式简介职责链(Chain of Responsibility)模式:避免将请求发送者与接受者耦合在⼀起,让多个对象都有机会接受请求,将这些对象连成⼀条链,并且沿着这条链传递请求,直到有对象处理它为⽌。

职责链模式是⼀种对象⾏为型模式。

1.2 需求需求背景:M公司承接了某企业SCM(Supply Chain Management,供应链管理)系统的开发任务,其中包含⼀个采购审批⼦系统。

该企业的采购审批是分级进⾏的,即根据采购⾦额的不同由不同层次的主管⼈员来审批:主任可以审批5万元以下(不包括5万)的采购单,副董事长可以审批5万~10万(不包括10万)的采购单,50万元以及以上的采购单就需要开董事会讨论决定,如下图所⽰:1.3 类图1.4 代码实现1.4.1 抽象执⾏者类// 抽象执⾏者类class AbstractApprover{public:explicit AbstractApprover(string strName = ""){} // 防⽌隐式转换virtual ~AbstractApprover(){}void SetSucessor(AbstractApprover* pSucessor){m_pSucessor = pSucessor;}virtual void ProcessRequest(CRequestX *) = 0;protected:string m_strName;AbstractApprover* m_pSucessor;};1.4.2 主管类// 主管类class CDirector : public AbstractApprover{public:explicit CDirector(string strName = ""){m_strName = strName;}~CDirector(){}void ProcessRequest(CRequestX *pRequest){if (pRequest->m_fAmount < 50000){cout << "主管:"<< m_strName.c_str() << "审批采购单:" << pRequest->m_strNumber.c_str() << "" << pRequest->m_fAmount << "" << "元," << "采购⽬的" << pRequest->m_strPurpose.c_str() << endl; }else{m_pSucessor->ProcessRequest(pRequest);}}};1.4.3 副总裁类// 副总裁类class CVicePresident : public AbstractApprover{public:explicit CVicePresident(string strName = ""){m_strName = strName;}~CVicePresident(){}void ProcessRequest(CRequestX *pRequest){if (pRequest->m_fAmount < 100000){cout << "副总裁:"<< m_strName.c_str() << "审批采购单:" << pRequest->m_strNumber.c_str() << "" << pRequest->m_fAmount << "" << "元," << "采购⽬的" << pRequest->m_strPurpose.c_str() << endl; }else{m_pSucessor->ProcessRequest(pRequest);}}};1.4.4 总裁类// 总裁类class CPresident : public AbstractApprover{public:explicit CPresident(string strName = ""){m_strName = strName;}~CPresident(){}void ProcessRequest(CRequestX *pRequest){if (pRequest->m_fAmount < 500000){cout << "总裁:"<< m_strName.c_str() << "审批采购单:" << pRequest->m_strNumber.c_str() << "" << pRequest->m_fAmount << "" << "元," << "采购⽬的" << pRequest->m_strPurpose.c_str() << endl; }else{m_pSucessor->ProcessRequest(pRequest);}}};1.4.5 董事会类// 董事会类class CCongress : public AbstractApprover{public:explicit CCongress(string strName = ""){m_strName = strName;}~CCongress(){}void ProcessRequest(CRequestX *pRequest){cout << "董事会:"<< m_strName << "审批采购单:" << pRequest->m_strNumber << "" <<pRequest->m_fAmount << "" << "元," << "采购⽬的" << pRequest->m_strPurpose << endl;}};1.5 测试#include "stdio.h"#include "responsibility.h"void main(){// 创建职责链AbstractApprover *PDirector = new CDirector("主管");AbstractApprover *pVicePresident = new CVicePresident("副总裁");AbstractApprover *pPresident = new CPresident("总裁");AbstractApprover *pCongress = new CCongress("董事会");PDirector->SetSucessor(pVicePresident);pVicePresident->SetSucessor(pPresident);pPresident->SetSucessor(pCongress);// 构造采购请求单并发送审批请求CRequestX* request1 = new CRequestX(45000.00,"MANULIFE201706001","购买PC和显⽰器");PDirector->ProcessRequest(request1);CRequestX* request2 = new CRequestX(60000.00,"MANULIFE201706002","2017开发团队活动");PDirector->ProcessRequest(request2);CRequestX* request3 = new CRequestX(160000.00,"MANULIFE201706003","2017公司年度旅游");PDirector->ProcessRequest(request3);CRequestX* request4 = new CRequestX(800000.00,"MANULIFE201706004","租⽤新临时办公楼");PDirector->ProcessRequest(request4);return;}⼆职责链模式总结2.1 主要优点 (1)使得⼀个对象⽆需知道是其他哪⼀个对象处理其请求,对象仅需知道该请求会被处理即可,且链式结构由客户端创建 => 降低了系统的耦合度 (2)在系统中增加⼀个新的具体处理者⽆须修改原有系统源代码,只需要在客户端重新建⽴链式结构即可 => 符合开闭原则2.2 主要缺点 (1)由于⼀个请求没有⼀个明确地接受者 => ⽆法保证它⼀定会被处理 (2)对于较长的职责链 => 系统性能有⼀定影响且不利于调试 (3)如果建⽴链不当,可能会造成循环调⽤ => 导致系统进⼊死循环2.3 应⽤场景 (1)有多个对象处理同⼀个请求且⽆需关⼼请求的处理对象时谁以及它是如何处理的 => ⽐如各种审批流程 (2)可以动态地指定⼀组对象处理请求,客户端可以动态创建职责链来处理请求,还可以改变链中处理者之间的先后次序 => ⽐如各种流程定制。

职责链设计模式

职责链设计模式

职责链设计模式一、什么是职责链设计模式职责链设计模式(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)

责任链模式(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个处理者对象没有下家。

深入理解设计模式(12):职责链模式

深入理解设计模式(12):职责链模式

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

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

使编程更有灵活性。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

各个组件间完全解耦。

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

软件工程责任链模式终稿

软件工程责任链模式终稿
软件工程责任链模式终稿
目录
责任链模式 简介
02
意图
01
优点缺点
04
03
实例
总结
05
01
责任链模式简介
责任链模式
设计模式: 设计模式(Design pattern)代表了最佳 的实践,通常被有经验的面向对象的软 件开发人员所采用。设计模式是软件开 发人员在软件开发过程中面临的一般问 题的解决方案。这些解决方案是众多软 件开发人员经过相当长的一段时间的试 验和错误总结出来的。
责任链实例
UML图:
责任链模式一个实例: 记录器接受到消息判断级别是否属于自 己的级别,如果是则相应地打印出来, 否则将不打印并把消息传给下一个记录 器。 每个记录器都有setNextLogger()方法用 于将不属于自己的消息传递到下一个记 录器。
责任链实例
UML图:
记录器抽象类:
责任链实例
AbstractLogger.java
责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的 链。这种模式给予请求的类型,对请求的发 送者和接收者进行解耦。这种类型的设计式 属于行为型模式。 在这种模式中,通常每个接收者都包含对另 一个接收者的引用。如果一个对象不能处理 该请求,那么它会把相同的请求传给下一个 接收者,依此类推。
责任链模式
责任链模式的通俗解释:
在食堂吃饭,你想吃牛肉面,到了第一 个窗口。问阿姨,我要一份牛肉面,阿 姨说我这里只有蛋炒饭,你去二号窗口 看一看。到了第二个窗口,阿姨说我这 里只有粥,你去第三个窗口看一下。就 这样一直吃到牛肉面为止。
02
责任链模式意图
责任链模式意图
引入责任链模式的目的是:避免请求发送 者与接收者耦合在一起,让多个对象都有 可能接收 处理它为止。 责任链解决的问题:职责链上的处理者负 责处理请求,客户只需要将请求发送到职 责链上即可,无须关心请求的处理细节和 请求的传递,所以职责链将请求的发送者 和请求的处理者解耦了。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

2.具体处理者(ConcreteHandler)_2: Shanghai.java 具体处理者(ConcreteHandler)
public class Shanghai implements Handler{ private Handler handler; private ArrayList<String> numberList; Shanghai(){ numberList=new ArrayList<String>(); numberList.add("34529812340930034"); numberList.add("98720810340430632"); numberList.add("36529812340930034"); numberList.add("77720810340930632"); } public void handleRequest(String number){ if(numberList.contains(number)) System.out.println("该人在上海居住 该人在上海居住"); System.out.println("该人在上海居住"); else{ System.out.println("该人不在上海居住 该人不在上海居住"); System.out.println("该人不在上海居住"); if(handler!=null) handler.handleRequest(number); } } public void setNextHandler(Handler handler){ this.handler=handler; } }
2010-6-9 12
3.应用 Application.java
public class Application{ private Handler beijing,shanghai,tianjin; public void createChain(){ beijing=new Beijing(); shanghai=new Shanghai(); tianjin=new Tianjin(); beijing.setNextHandler(shanghai); shanghai.setNextHandler(tianjin); } public void reponseClient(String number){ beijing.handleRequest(number); } public static void main(String args[]){ Application application=new Application(); application.createChain(); application.reponseClient("77720810340930632");; } }
一 , 概述
责任链模式是使用多个对象处理用户请求 的成熟模式, 的成熟模式,责任链模式的关键是将用户的请 求分派给许多对象, 求分派给许多对象,这些对象被组织成一个责 任链,即每个对象含有后继对象的引用, 任链,即每个对象含有后继对象的引用,并要 求责任链上的每个对象, 求责任链上的每个对象,如果能处理用户的请 就做出处理, 求,就做出处理,不再将用户的请求传递给责 任链上的下一个对象;如果不能处理用户的请 任链上的下一个对象; 求,就必须将用户的请求传递给责任链上的下 一个对象. 一个对象.
第九章 责任链模式
责任链模式 使多个对象都有机会处理请求, 使多个对象都有机会处理请求 , 从而避免请求的发送者 和接收者之间的耦合关系.将这些对象连成一条链, 和接收者之间的耦合关系 . 将这些对象连成一条链 , 并 沿着这条链传递该请求,直到有一个对象处理它为止. 沿着这条链传递该请求,直到有一个对象处理它为止. Chain of Responsibility Pattern Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
public class UseInt implements Handler{ private Handler handler; private int result=1 ; public void compuerMultiply(String number){ try{ int n=Integer.parseInt(number); int i=1; while(i<=n){ result=result*i; if(result<=0){ System.out.println("超出我的能力范围,我计算不了"); puerMultiply(number); return; } i++; } System.out.println(number+"的阶乘:"+result); } catch(NumberFormatException exp){ System.out.println(exp.toString()); } } public void setNextHandler(Handler handler){ this.handler=handler; } }
2010-6-9 4
二,责任链模式的结构与使用
模式的结构中包括两种角色: 模式的结构中包括两种角色: 处理者(Handler) 处理者(Handler) 具体处理者(ConcreteHandler) 具体处理者(ConcreteHandler)
2010-6-9 5
模式的UML类图 模式的UML类图 UML
2010-6-9 6
aClient aHandler
aConcreteHandler successor
aConcreteHandler successor
模式的结构的描述与使用
用户提交一个人的身份证号码,想知道该 人是否在北京,上海或天津居住.
1.处理者(Handler): Handler.java 处理者(Handler)
2010-6-9 13
三,责任链模式的优点 责任链中的对象只和自己的后继是低耦合关系,和其他
对象毫无关联,这使得编写处理者对象以及创建责任链 变得非常容易.
当在处理者中分配职责时,责任链给应用程序更多的灵
活性.
应用程序可以动态地增加,删除处理者或重新指派处理
者的职责.
应用程序可以动态地改变处理者之间的先后顺序. 使用责任链的用户不必知道处理者的信息,用户不会知
道到底是哪个对象处理了它的请求.
2010-6-9 14
四,应用举例
// Handler.java public interface Handler{ public abstract void compuerMultiply(String number); public abstract void setNextHandler(Handler handler); }
2010-6-9 1

Chain of Responsibility模式在军队中也有应用的例子.某个下级军官要求得 到上级军官的许可,这个请求将由其直接上级军官再报给上级军官的上级军 官,直到某个上级军官有权利做决定为止.如果一名水兵请求进入某个海军 基地,他说执行的请求过程就是Chain of Responsibility的实例.
2010-6-9 9
2.具体处理者(ConcreteHandler)_1: Beijing.java 具体处理者(ConcreteHandler)
public class Beijing implements Handler{ handler; private Handler handler; numberList; private ArrayList<String> numberList; Beijing(){ ArrayList<String>(); numberList=new ArrayList<String>(); numberList.add("11129812340930034"); 11129812340930034") numberList.add("11129812340930034"); numberList.add("10120810340930632"); 10120810340930632") numberList.add("10120810340930632"); numberList.add("22029812340930034"); 22029812340930034") numberList.add("22029812340930034"); numberList.add("32620810340930632"); 32620810340930632") numberList.add("32620810340930632"); } public void handleRequest(String number){ if(numberList. if(numberList.contains(number)) System.out.println("该人在北京居住"); 该人在北京居住") System.out.println("该人在北京居住"); else{ System.out.println("该人不在北京居住"); 该人不在北京居住") System.out.println("该人不在北京居住"); if(handler!=null) handler.handleRequest(number); handler.handleRequest(number); } } public void setNextHandler(Handler handler){ this.handler=handler; this.handler=handler; 2010-6-9 10 }}
相关文档
最新文档