- 浏览: 94924 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
longhaojava:
谢谢,文章很好,对我帮助很大,感谢楼主的分享!
设计模式学习笔记(十七)—Memento备忘录模式 -
枫竹雨:
可以把这个例子发给我吗?我近期在学这方面的东西。谢谢。
我的邮 ...
Struts2+spring2+hibernate3整合方案 -
fengzhizi8584:
学习了~~~~
设计模式学习笔记(一)--Facade外观模式 -
lxtkong-029:
谢谢,郁闷了半天了
Struts2中使用Common-FileUpload实现文件上传 -
女巫の微笑:
条理很清晰
Struts2拦截器学习
自从辞职以来,一个多月了只收到一份面试通知,到最后还是不了了之。哎,伤心。。。无聊死了。还好,可以利用这段时间好好充充电,但是由于心情不好,学过的东西很容易忘记,所以就在博客里写下来。由于本人水平有限,写出来的东西也许对初学者有所帮助。如果不小心哪位大侠看了不要见笑,哪里有不正确的地方还请批评指正。好了不说废话了。
Chain of Responsibility模式定义:
为了避免请求的发送者和接收者之间的耦合关系,使多个接受对象都有机会处理请求。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
我的理解:
在不止一个对象可以处理客户端请求的时候,为了使每个对象都有处理请求的机会,把这些对象顺序地串联起来形成一个链,每个被串联的对象都有一个指向下一个对象的指针,当请求到来是,按照顺序,先有第一个对象来处理这个请求,这个对象有两个选择:要么处理,要么把请求传给下一个对象(每个对象都有这两个选择),就这样一直到有一个对象来处理这个请求为止,一旦有一个对象处理了这个请求就停止对请求的传递。当然也有可能到了对象链的最后,也没有一个对象来处理请求。我觉得这个与我们平常写的if…else if…else…要完成的功能太相似了。以上所说的只是Chain of Responsibility的一种情况,有的书上叫它纯职责链模式(我能处理就处理,不能处理才让别人处理),它还有另一种情况也就是不纯职责链模式(我只处理我能处理的部分,处理不了的部分再让别人来处理)。
Chain of Responsibility模式主要涉及两个角色:
1) 抽象处理者角色(Handler):它定义了一个处理请求的接口。当然对于链子的不同实现,也可以在这个角色中实现后继链。
2) 具体处理者角色(Concrete Handler):实现抽象角色中定义的接口,并处理它所负责的请求。如果不能处理则访问它的后继者。
由于这个模式的UML比较简单,我就不再画出来了。下面我举个例子:一个纯的和一个不纯的。先来个纯的:
现在的女孩子找男朋友基本上都有三个要求:有车、有房、有责任心,如果你这三样都没有,就险了。虽然我没车、也没房、但是我有责任心。^_^
class Boy{
private boolean hasCar; //是否有车
private boolean hasHouse; //是否有房
private boolean hasResponsibility; //是否有责任心
public Boy() {
}
public Boy(boolean hasCar, boolean hasHouse, boolean hasResponsibility) {
this.hasCar = hasCar;
this.hasHouse = hasHouse;
this.hasResponsibility = hasResponsibility;
}
public boolean isHasCar() {
return hasCar;
}
public void setHasCar(boolean hasCar) {
this.hasCar = hasCar;
}
public boolean isHasHouse() {
return hasHouse;
}
public void setHasHouse(boolean hasHouse) {
this.hasHouse = hasHouse;
}
public boolean isHasResponsibility() {
return hasResponsibility;
}
public void setHasResponsibility(boolean hasResponsibility) {
this.hasResponsibility = hasResponsibility;
}
}
interface Handler{
public void handleRequest(Boy boy);
}
class CarHandler implements Handler{//检查是否有车
private Handler handler;
public CarHandler(Handler handler) {
this.handler = handler;
}
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
public void handleRequest(Boy boy) {
if(boy.isHasCar()){
System.out.println("呵呵,我有辆车");
}else{
System.out.println("我没有车");
handler.handleRequest(boy);
}
}
}
class HouseHandler implements Handler{ //检查是否有房
private Handler handler;
public HouseHandler(Handler handler) {
this.handler = handler;
}
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
public void handleRequest(Boy boy) {
if(boy.isHasHouse()){
System.out.println("没想到吧,我还有房子");
}else{
System.out.println("我也没有房");
handler.handleRequest(boy);
}
}
}
class ResponsibilityHandler implements Handler{ //检查是否有责任心
private Handler handler;
public ResponsibilityHandler(Handler handler) {
this.handler = handler;
}
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
public void handleRequest(Boy boy) {
if(boy.isHasResponsibility()){
System.out.println("我只有一颗带Responsibility的心");
}else{
System.out.println("更没有责任心");
handler.handleRequest(boy);
}
}
}
class Girl{
public static void main(String[] args){
Boy boy=new Boy(false,false,true);//这个boy没有车,也没有房,不过很有责任心
Handler handler=new CarHandler(new HouseHandler(new ResponsibilityHandler(null)));//也可以使用setHanlder方法
handler.handleRequest(boy);
}
}
为了编这个例子,我死了好多脑细胞。。。。。。。。。。
下面再来个不纯的:
为了让减少脑细胞的死亡数量,这个例子我就不编了,用网上一位大侠所写的。
这个例子模拟了汽车组装的过程:假设一辆汽车从生产到出厂要经过以下四个过程:组装车头,车身,车尾,以及上色。
abstract class CarHandler {
public static final int STEP_HANDLE_HEAD = 0;
public static final int STEP_HANDLE_BODY = 0;
public static final int STEP_HANDLE_TAIL = 0;
public static final int STEP_HANDLE_COLOR = 3;
protected CarHandler carHandler;
public CarHandler setNextCarHandler(CarHandler carHandler) {
this.carHandler = carHandler;
return this.carHandler;
}
abstract public void handleCar(int lastStep);
}
class CarHeadHandler extends CarHandler {
@Override
public void handleCar(int lastStep) {
if (STEP_HANDLE_HEAD <= lastStep) {
System.out.println("Handle car's head.");
}
if (carHandler != null) {
carHandler.handleCar(lastStep);
}
}
}
class CarBodyHandler extends CarHandler {
@Override
public void handleCar(int lastStep) {
if (STEP_HANDLE_BODY <= lastStep) {
System.out.println("Handle car's body.");
}
if (carHandler != null) {
carHandler.handleCar(lastStep);
}
}
}
class CarTailHandler extends CarHandler {
@Override
public void handleCar(int lastStep) {
if (STEP_HANDLE_TAIL <= lastStep) {
System.out.println("Handle car's tail.");
}
if (carHandler != null) {
carHandler.handleCar(lastStep);
}
}
}
class CarColorHandler extends CarHandler {
@Override
public void handleCar(int lastStep) {
if (STEP_HANDLE_COLOR == lastStep) {
System.out.println("Handle car's color.");
}
if (carHandler != null) {
carHandler.handleCar(lastStep);
}
}
}
public class Client {
public static void main(String[] args) {
//工作流程1:先组装车头,然后是车身,车尾,最后是上色
System.out.println("---workfolow1----");
CarHandler carHandler1 = new CarHeadHandler();
carHandler1.setNextCarHandler(
new CarBodyHandler()).setNextCarHandler(
new CarTailHandler()).setNextCarHandler(
new CarColorHandler());
carHandler1.handleCar(CarHandler.STEP_HANDLE_COLOR);
//工作流程2:因为某种原因,我们需要先组装车尾,然后是车身,车头,最后是上色
System.out.println("---workfolow2---");
CarHandler carHandler2 = new CarTailHandler();
carHandler2.setNextCarHandler(
new CarBodyHandler()).setNextCarHandler(
new CarHeadHandler()).setNextCarHandler(
new CarColorHandler());
carHandler2.handleCar(CarHandler.STEP_HANDLE_COLOR);
}
}
模式的使用范围:
1) 有多个的对象可以处理一个请求,哪个对象处理该请求运行时刻自动确定。
2) 你想在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。
3) 可处理一个请求的对象集合应被动态指定。
优缺点:
1) 责任的分担。每个类只需要处理自己该处理的工作(不该处理的传递给下一个对象完成),明确各类的责任范围,符合类的最小封装原则。
2) 可以根据需要自由组合工作流程。如工作流程发生变化,可以通过重新分配对象链便可适应新的工作流程。
3) 类与类之间可以以松耦合的形式加以组织。
4) 责任链模式可能会带来一些额外的性能损耗,因为它要从链子开头开始遍历。
发表评论
-
设计模式学习笔记(一)--Facade外观模式
2007-11-23 01:45 977GOF《设计模式》一书对Facade模式是这样 ... -
设计模式学习笔记(二)—-Adapter适配器模式
2007-11-23 18:40 785GOF《设计模式》一书对Adapter模式是这样描述的: ... -
设计模式学习笔记(三)—-Strategy策略模式
2007-11-23 18:43 947GOF《设计模式》一书对Strategy模式是这样描述的: ... -
设计模式学习笔记(四)—Bridge桥接模式
2007-11-28 15:48 898《设计模式》一书对Bridge是这样描述的: 将抽象与其 ... -
设计模式学习笔记(五)—Abstract Factory抽象工厂模式
2007-11-28 20:23 840GOF《设计模式》一书对Abstract ... -
设计模式学习笔记(六)—Decorator装饰模式
2007-11-28 20:31 822《设计模式》一书对Decorator是这样描述的: 动态地给 ... -
设计模式学习笔记(七)—Observer观察者模式
2007-11-28 20:34 820《设计模式》一书对Ob ... -
设计模式学习笔记(八)—Template Method模式
2007-11-28 20:36 854《设计模式》一书对Template Method模式是这样描 ... -
设计模式学习笔记(九)—Singleton模式
2007-11-28 20:39 977《设计模式》一书对Singleton模式是这样描述的: 保证 ... -
设计模式学习笔记(十)—Factory Method模式
2007-11-29 17:41 921《设计模式》一书对Factory Method模式是这 ... -
设计模式学习笔记(十一)—Prototype原型模式
2007-12-02 16:16 860Prototype模式的意图是: 通过给出一个原型对象来指 ... -
设计模式学习笔记(十二)—Builder建造者模式
2007-12-03 21:39 954Builder模式定义: 将一个复杂对象的构建与它的表示分离, ... -
设计模式学习笔记(十三)—Iterator迭代器模式
2007-12-04 23:52 893Iterator模式定义: 提供一个方法顺序访问一个聚合对象的 ... -
设计模式学习笔记(十四)—Command模式
2007-12-05 13:23 1061一、 Command模式定义: 将一个请求封装为一个对象,从而 ... -
设计模式学习笔记(十五)—State模式
2007-12-05 16:35 1493一、 State模式定义: 允许一个对象在其状态改变时,改变它 ... -
设计模式学习笔记(十六)—Proxy模式
2007-12-06 13:19 1171一、 Proxy模式定义: 为其他对象提供一种代理以控制这个对 ... -
设计模式学习笔记(十七)—Memento备忘录模式
2007-12-08 15:25 1083一、 模式定义: 在不破坏封装的前提下,捕获一个对象的内部状态 ... -
设计模式学习笔记(十八)—Mediator中介者模式
2007-12-12 20:34 1303设计模式学习笔记(十八)—Mediator中介者模式 一、 模 ... -
设计模式学习笔记(二十)—Visitor访问者模式
2007-12-15 18:37 1000Visitor模式定义: 表示一个作用于某对象结构中各元素的操 ... -
设计模式学习笔记(二十一)—Composite模式
2007-12-18 17:10 1271今天开始学习Composite模式,首先让我们看一下它的定义: ...
相关推荐
设计模式学习笔记,分析了GOF的23种模式和类设计的原则
Java设计模式学习笔记
《C++20设计模式》学习笔记-第13章职责链模式-配套代码
我收集的设计模式的学习笔记,采用pdf格式,便于收藏和查看
各个模式都有详细的例子C#学习笔记,打开就知道了
HeadFirst设计模式学习笔记比较全面详细地讲解了13个设计模式,有利于大家更好的学习HeadFirst设计模式,希望亲们会喜欢~~~
总结了java开发中的21种设计模式,详解和例子,带书签的pdf格式,方便阅读!
设计模式学习笔记.ppt 自己写的一点学习笔记。
设计模式学习笔记,总共23个设计模式,还有几个设计原则
设计模式学习笔记(九)桥接模式及其应用.doc
23种设计模式学习笔记及源码,全部原创 欢迎提出意见和建议
Head First 设计模式学习笔记。更多内容请参见文章内容。
学习Java设计模式的笔记,标注了其中重要的要点,如果有需要的小伙伴,自行下载哦
设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx
代理模式学习笔记、单例模式学习笔记、命令模式、原型模式、模式特点总结。 为个人对设计模式的理解,如果有理解不一致的不要砸砖啊
行为型模式:模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式(Interpreter模式)、状态模式、策略模式、职责链模式(责任链模式) 2) 学习目标:通过学习,学员...
学习设计模式入门的好材料 简单明了,一看就懂 帮助你快速学习或是复习23种设计模式
设计模式学习笔记-命令模式
资源名称:设计模式C 学习笔记资源目录:【】设计模式C 学习笔记源代码【】设计模式C 学习笔记目录【】设计模式C 学习笔记(1)【】设计模式C 学习笔记(2)【】设计模式C 学习笔记(3)【】设计模式C 学习笔记(4)...
Head.First 设计模式学习笔记.pdf Head.First 设计模式学习笔记.pdf