设计模式—Chain of Responsibility职责链模式

 

设计模式—Chain of Responsibility职责链模式

为了避免请求的发送者和接收者之间的耦合关系，使多个接受对象都有机会处理请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

　　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)责任链模式可能会带来一些额外的性能损耗，因为它要从链子开头开始遍历。