- 浏览: 65723 次
- 性别:
- 来自: 上海
最新评论
-
java苹果+番茄:
已经修改,感谢大家提的意见;有一年多没进来了,很惭愧;以后一定 ...
java设计模式笔记链接地址汇总 -
youthon:
命令(Command)模式【行为模式第九篇】的链接应为http ...
java设计模式笔记链接地址汇总 -
youthon:
你给的链接只有你自己才能打开,你改改吧
java设计模式笔记链接地址汇总 -
shaozhi_jinni:
[b][/b][i][/i][u][/u]引用引用
[img ...
模板方法(Template Method)模式【行为模式第十篇】 -
Tank03:
慢慢的走~
android开发学习中(已经学会了几个小玩意),兴趣大增
责任链(Chain of Responsibility)模式
责任链模式是一种对象行为模式。
在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。
发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。
责任链模式的角色:
1、抽象处理者角色:定义出一个处理请求的接口。如果需要,接口可以定义出一个方法,以设定和返回对下家的引用。这个角色通常由
一个java抽象类或者java接口实现。
2、具体处理者角色:具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家,由于具体处理者持有对下家的引用,因此
,如果需要,具体处理者可以访问下家。
纯的与不纯的责任链模式
一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个:一是承担责任,二是把责任推给下家。
不允许出现某一个具体处理者对象在承担了一部分责任后又把责任向下传的情况。
在一个纯的责任链模式里面,一个请求必须被某一个处理者对象所接受,在一个不纯的责任链模式里面,一个请求可以最终不被
任何接受端对象所接收。
在下面的情况下可以使用责任链模式:
(1)系统已经有一个由处理者对象组成的链。这个链可能由合成模式给出。
(2)有多于一个的处理者对象会处理一个请求,而且事先并不知道到底由哪一处理者对象处理一个请求。
这个处理者对象是动态确定的。
(3)系统想发出一个请求给多个处理者对象中的某一个,但是不明显指定是哪一个处理者对象会处理此请求。
(4)处理一个请求的处理者对象的集合需要动态地指定时。
责任链模式降低了发出命令的对象和处理命令的对象之间的耦合,它允许多于一个的处理者对象根据自己的逻辑来决定
哪一个处理者最终处理这个命令。换言之,发出命令的对象只是把命令传给链结构的起始者,而不需要知道到底是链上
的哪一个节点处理了这个命令。
显然。这意味着在处理命令时,允许系统有更多的灵活性。哪一个对象最终处理一个命令可以因为由哪些对象参加责任链,
以及这些对象在责任链上的位置不同而有所不同。
责任链模式是一种对象行为模式。
在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。
发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。
责任链模式的角色:
1、抽象处理者角色:定义出一个处理请求的接口。如果需要,接口可以定义出一个方法,以设定和返回对下家的引用。这个角色通常由
一个java抽象类或者java接口实现。
2、具体处理者角色:具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家,由于具体处理者持有对下家的引用,因此
,如果需要,具体处理者可以访问下家。
//抽象处理者 public abstract class Hander{ //处理方法,调用此方法处理请求 protected Handle 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 handlerRequest(){ if(getSuccessor() != null){ System.out.println("The request is passed to " + getSuccessor()); getSuccessor().handlerRequest(); }else{ System.out.println("The request is handled here."); } } } //客户端 public class Client{ private static Handler handler1, handler2; public static void main(String args[]){ handler1 = new ConcreteHandler(); handler2 = new ConcreteHandler(); handler1.setSuccessor(handler2); handler1.handleRequest(); } }
纯的与不纯的责任链模式
一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个:一是承担责任,二是把责任推给下家。
不允许出现某一个具体处理者对象在承担了一部分责任后又把责任向下传的情况。
在一个纯的责任链模式里面,一个请求必须被某一个处理者对象所接受,在一个不纯的责任链模式里面,一个请求可以最终不被
任何接受端对象所接收。
//一个贾家击鼓传花喝酒的例子 //击鼓者(客户端) public class DrumBeater{ private static Player player; public static void main(String[] args){ //创建责任链 player = new JiaMu(new JiaShe(new JiaZheng(new JiaBaoYu(new JiaHuan(null))))); //规定由第四个处理者处理请求 player.handler(4); } } 抽象传花者 public abstract class Player{ public abstract void handler(int i); private Player successor; public Player(){ successor = null; } protected void setSuccessor(Player aSuccessor){ successor = aSuccessor; } //将花传给下家,如果没有下家,系统停止运行 public void next(int index){ //判断下家对象是否有效 if(successor != null){ //将请求传给下家 successor.handler(index); }else{ //系统停止运行 System.out.println("Program terminated."); System.exit(0); } } } //JiaMu类 public class JiaMu extends Player{ public JiaMu(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handler(int i){ if(i == 1){ System.out.println("Jia Mu gotta drink!"); }else{ System.out.println("JiaMu passed!"); next(i); } } } //JiaShe public class JiaShe extends Player{ public JiaShe(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handler(int i){ if(i == 2){ System.out.println("Jia She gotta drink!"); }else{ System.out.println("Jia She passed!"); next(i); } } } public class JiaZheng extends Player{ public JiaZheng(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handler(int i){ if(i == 3){ System.out.println("Jia Zheng gotta drink!"); }else{ System.out.println("Jia Zheng passed!"); next(i); } } } public class JiaBaoYu extends Player{ public JiaBaoYu(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handler(int i){ if(i == 4){ System.out.println("Jia Bao Yu gotta drink!"); }else{ System.out.println("Jia Bao Yu passed!"); next(i); } } } public class JiaHuan extends Player{ public JiaHuan(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handler(int i){ if(i == 5){ System.out.println("Jia Huan gotta drink!"); }else{ System.out.println("Jia Huan passed!"); next(i); } } }
在下面的情况下可以使用责任链模式:
(1)系统已经有一个由处理者对象组成的链。这个链可能由合成模式给出。
(2)有多于一个的处理者对象会处理一个请求,而且事先并不知道到底由哪一处理者对象处理一个请求。
这个处理者对象是动态确定的。
(3)系统想发出一个请求给多个处理者对象中的某一个,但是不明显指定是哪一个处理者对象会处理此请求。
(4)处理一个请求的处理者对象的集合需要动态地指定时。
责任链模式降低了发出命令的对象和处理命令的对象之间的耦合,它允许多于一个的处理者对象根据自己的逻辑来决定
哪一个处理者最终处理这个命令。换言之,发出命令的对象只是把命令传给链结构的起始者,而不需要知道到底是链上
的哪一个节点处理了这个命令。
显然。这意味着在处理命令时,允许系统有更多的灵活性。哪一个对象最终处理一个命令可以因为由哪些对象参加责任链,
以及这些对象在责任链上的位置不同而有所不同。
//一个使用Timer的例子 import java.util.Timer; import java.util.TimerTask; public class Reminder{ Timer timer; //构造子,在seconds秒后执行一个任务 public Reminder(int seconds){ timer = new Timer(); timer.schedule(new RemindTask(),seconds*1000); //schedule(清单,目录) } //内部成员类,描述将要执行的任务 class RemindTask extends TimerTask{ public void run(){ System.out.println("Time's up!"); timer.cancle(); } } public static void main(String[] args){ System.out.println("About to schedule task."); new Reminder(5); System.out.println("Task scheduled."); } } //Timer类是线程安全的,换言之,可以有多个线程共享同一个Timer对象,而不需要同步化。这是使用Timer的一个好处。 //击鼓者(相当于客户端) import java.lang.Thread; import java.util.Timer; import java.util.TimerTask; public class DrumBeater{ private static Player firstPlayer; public static boolean stopped = false; Timer timer; public static void main(String[] args){ DrumBeater drumBeater = new DrumBeater(); JiaMu jiaMu = new JiaMu(null); JiaMu.setSuccessor(new JiaShe(new JiaZheng(new JiaBaoYu(new JiaHuan(jiaMu))))); //开始击鼓过程 drumBeater.startBeating(1); //由贾母开始传花 firstPlayer = jiaMu; firstPlayer.handle(); } //调用下面方法,开始击鼓过程 public void startBeating(int stopInSeconds){ System.out.println("Drum beating started..."); timer = new Timer(); timer.schedule(new StopBeatingReminder(),stopInSeconds*1000); } //内部成员类,描述停止击鼓的任务 class StopBeatingReminder extends TimerTask{ public void run(){ System.out.println("Drum beating stopped!"); stopped = true; timer.cancel(); } } } //抽象传花者类 public abstract class Player{ public abstract void handle(); private Player successor; public Player(){ successor = null; } protected void setSuccessor(Player aSuccessor){ successor = aSuccessor; } public void next(){ //判断下家对象是否有效 if(successor != null){ //将请求传给下家 successor.handle(); }else{ //系统停止运行 System.out.println("Program is terminating."); System.exit(0); } } } //贾母 public class JiaMu extends Player{ public JiaMu(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handle(){ //检查是否击鼓已经停止] if(DrumBeater.stopped){ System.out.pritntln("Jia Mu gotta drink!"); }else{ System.out.println("Jia Mu passed!"); next(); } } } ...................... public class JiaHuan extends Player{ public JiaHuan(Player aSuccessor){ this.setSuccessor(aSuccessor); } public void handle(){ //检查是否击鼓已经停止] if(DrumBeater.stopped){ System.out.println("Jia Huan gotta drink!"); }else{ System.out.println("Jia Huan passed!"); next(); } } }
发表评论
-
java设计模式笔记链接地址汇总
2009-10-24 14:46 2252各位,这些笔记已经生成了pdf,如果有兴趣的可以在本文末尾下载 ... -
MVC模式【行为模式第十三篇】
2009-10-23 23:36 1478MVC模式:就是模型-视 ... -
状态(State Pattern)模式【行为模式第十二篇】
2009-10-23 23:35 1323状态(State Pattern)模式:又称为状态对象模式,状 ... -
模板方法(Template Method)模式【行为模式第十篇】
2009-10-23 23:32 1188模板方法(Template Method)模式 模板方法模式 ... -
命令(Command)模式【行为模式第九篇】
2009-10-23 23:31 1372命令(Command)模式: ... -
解释器(Interpreter)模式【行为模式第八篇】
2009-10-23 23:29 1075解释器(Interpreter)模 ... -
观察者(Observer)模式【行为模式第七篇】
2009-10-23 23:28 1228观察者(Observer)模式 ... -
访问者(Visitor)模式【行为模式第六篇】
2009-10-23 23:26 1065访问者(Visitor)模式: 访问者模式是对象的行为模式。 ... -
迭代子(Iterator)模式【行为模式第五篇】
2009-10-23 23:25 1410迭代子(Iterator)模式: 迭代子模式又叫游标(Cur ... -
调停者(Mediator)模式 【行为模式第四篇】
2009-10-23 23:23 2631调停者(Mediator)模式 调停者模式是对象的行为模式。 ... -
策略(Strategy)模式 【行为模式第三篇】
2009-10-23 23:22 1504策略(Strategy)模式 策略模式属于对象的行为模式。其 ... -
不变(Immutable)模式【行为模式第二篇】
2009-10-23 23:21 1645不变(Immutable)模式 一个对象的状态在对象被创建之 ... -
备忘录(Memento Pattern)模式 【行为模式第一篇】
2009-10-23 23:19 1951备忘录(Memento Pattern)模式 备忘录模式又叫 ... -
适配器模式举例【结构模式第八篇】
2009-10-23 23:17 1027XMLProperties与适配器模式举例: //---- ... -
适配器模式【结构模式第六篇】
2009-10-23 23:12 1156适配器模式(Adapter Pattern)(另称-变压器模式 ... -
桥梁(Bridge)模式【结构模式第五篇】
2009-10-23 23:09 1310桥梁(Bridge)模式: 一、桥梁模式的用意 桥梁模式 ... -
门面(Facade)模式【结构模式第四篇】
2009-10-23 23:08 1203门面(Facade)模式: 是对象的结构模式。外部与一个子系 ... -
亨元(Flyweight Pattern)模式【结构模式第三篇】
2009-10-23 23:07 1098亨元(Flyweight Pattern) ... -
合成(Composite)模型模式【结构模式第二篇】
2009-10-23 23:04 1348合成(Composite)模型模式: 属于对象的结构模式,有 ... -
代理(Proxy)模式 【结构模式第一篇】
2009-10-23 23:02 1365代理(Proxy)模式 是对 ...
相关推荐
23种设计模式之二十一(行为模式)Chain of Responsibility模式
设计模式C++学习之责任链模式(Chain of Responsibility)
【Java设计模式】(3)责任链Chain of Responsibility源码
C#面向对象设计模式 (行为型模式) Chain Of Responsibility 职责链模式 视频讲座下载
C#面向对象设计模式 Chain of Responsibility 职责链模式 视频讲座下载
chain of responsibility 职责链模式(行为模式)来自于Microsoft官方网站视频教程,详细介绍了职责链模式的运用,且在本人提供的资源里可以下载到相关的PDF辅助文档帮助
C#面向对象设计模式纵横谈(20):(行为型模式) Chain Of Responsibility 职责链模式
C#面向对象设计模式纵横谈(14):Chain of Responsibility 职责链模式(行为型模式) (Level 300)
C#面向对象设计模式纵横谈(14):Chain of Responsibility 职责链模式(行为型模式)
责任链模式(Chain of Responsibility Pattern)是一种常见的行为模式。 使多个对象都有处理请求的机会,从而避免了请求的发送者和接收者之间的耦合关系。将这些对象串成一条链,并沿着这条链一直传递该请求,直到有...
NULL 博文链接:https://stelin.iteye.com/blog/932101
chain-of-responsibility-demo 责任链模式demo
主要介绍了Java设计模式之责任链模式(Chain of Responsibility模式)介绍,本文讲解了如何使用责任链模式,并给出了4种使用实例,需要的朋友可以参考下
NULL 博文链接:https://linkcqu.iteye.com/blog/355806
NULL 博文链接:https://gary0416.iteye.com/blog/913457
Chain Of Responsibility.rar
责任链模式(Chain of Responsibility)的目标是使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止。 在处理用户的...
责任链(Chain of Responsibility)模式的定义:为了避免请求发送者与多个请求处理者耦合在一起,于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递...
责任链模式(Chain) 用意:避免请求发送者与接受者耦合在一起,让多个对象连接成一条链,并且沿关这条链传递请求,直至有对象处理他为止。