Java设计模式--责任链模式

责任链模式【Chain of Responsibility Pattern 】

以古代妇女三从（未嫁从父、既嫁从夫、夫死从子）为例。先看下刚开始的类图：

古代悲哀女性：

public interface IWomen {
    //获得个人状况
    public int getType();
    //获得个人请示，你要干什么？出去逛街？约会?还是看电影
    public String getRequest();
}

妇女实现类：

public class Women implements IWomen{
    /*
    * 通过一个int类型的参数来描述妇女的个人状况
    * 1---未出嫁
    * 2---出嫁
    * 3---夫死
    */
    private int type=0;
    //妇女的请示
    private String request = "";
    //构造函数传递过来请求
    public Women(int _type,String _request){
    this.type = _type;
    this.request = _request;
    }
    //获得自己的状况
    public int getType(){
    return this.type;
    }
    //获得妇女的请求
    public String getRequest(){
    return this.request;
    }
}

定义一个控制的接口：

public interface IHandler {
    //一个女性（女儿，妻子或者是母亲）要求逛街，你要处理这个请求
    public void HandleMessage(IWomen women);
}

写一个实现类：

public class Father implements IHandler {
    //未出嫁女儿来请示父亲
    public void HandleMessage(IWomen women) {
    System.out.println("女儿的请示是："+women.getRequest());
    System.out.println("父亲的答复是:同意");
    }
}

这样子的设计是可以实现这个功能的。

//定义三个请示对象
IHandler father = new Father();
IHandler husband = new Husband();
IHandler son = new Son();
for(IWomen women:arrayList){
if(women.getType() ==1){ //未结婚少女，请示父亲
System.out.println("\n--------女儿向父亲请示-------");
father.HandleMessage(women);
}else if(women.getType() ==2){ //已婚少妇，请示丈夫
System.out.println("\n--------妻子向丈夫请示-------");
husband.HandleMessage(women);
}else if(women.getType() == 3){ //母亲请示儿子
System.out.println("\n--------母亲向儿子请示-------");
son.HandleMessage(women);
}else{
//暂时啥也不做
}
}

但是在体会一下，就会发现这样子的设计存在比较多的弊端。
（1）迪米特法则相违背。我们在 Client 类中写了 if…eles 的判断条件，你看这个条件体内都是一个接口IHandler 的三个实现类，谁能处理那个请求，怎么处理，直接在实现类中定义好不就结了吗。

（2）耦合过重，，我们要根据 Women 的 type 来决定使用 IHandler 的那个实现类来处理请求，如果IHanlder 的实现类继续扩展，就无法解决了，与开闭原则违背。

（3）异常情况没有考虑。妻子只能向丈夫请示吗？如果妻子向自己的父亲请示了，父亲应该做何处理？我们的程序上可没有体现出来。

通过上面的弊端就可以再设计一下：

如果这样子设计的话，那么就有一条清晰的责任链出来了。父亲、丈夫、儿子每个节点有两个选择：要么承担责任，做出回复；要么把请求转发到后序环节。看下类图：

从类图上看，三个实现类 Father、Husband、Son 只要实现构造函数和父类的中抽象方法就可以了，具体怎么处理这些请求，都已经转移到了 Hanlder 抽象类中。

Handler 类的定义：

public abstract class Handler {
    //能处理的级别
    private int level =0;
    //责任传递，下一个人责任人是谁
    private Handler nextHanlder;
    //每个类都要说明一下自己能处理哪些请求
    public Handler(int _level){
    this.level = _level;
    }
    //一个女性（女儿，妻子或者是母亲）要求逛街，你要处理这个请求
    public final void HandleMessage(IWomen women){
    if(women.getType() == this.level){
    this.response(women);
    }else{
    if(this.nextHanlder != null){ //有后续环节，才把请求往后递送
    this.nextHanlder.HandleMessage(women);
    }else{ //已经没有后续处理人了，不用处理了
    System.out.println("-----------没地方请示了， 不做处理！ ---------\n");
    }
    }
    }
    /*
    * 如果你属于你处理的返回，你应该让她找下一个环节的人，比如
    * 女儿出嫁了，还向父亲请示是否可以逛街，那父亲就应该告诉女儿，应该找丈夫请示
    */
    public void setNext(Handler _handler){
    this.nextHanlder = _handler;
    }
    //有请示那当然要回应
    public abstract void response(IWomen women);
    }

在这里也用到模版方法模式，在模版方法中判断请求的级别和当前能够处理的级别，如果相同则调用基本方法，做出反馈；如果不相等，则传递到下一个环节，由下一环节做出回应。

父亲的实现类：

public class Father extends Handler {
    //父亲只处理女儿的请求
    public Father(){
    super(1);
    }
    //父亲的答复
    @Override
    public void response(IWomen women) {
    System.out.println("--------女儿向父亲请示-------");
    System.out.println(women.getRequest());
    System.out.println("父亲的答复是:同意\n");
    }
}

妇女可以做如下定义：

public class Women implements IWomen{
    /*
    * 通过一个int类型的参数来描述妇女的个人状况
    * 1---未出嫁
    * 2---出嫁
    * 3---夫死
    */
    private int type=0;
    //妇女的请示
    private String request = "";
    //构造函数传递过来请求
    public Women(int _type,String _request){
    this.type = _type;
    //为了显示好看点，我在这里做了点处理
    switch(this.type){
    case 1:
    this.request = "女儿的请求是：" + _request;
    break;
    case 2:
    this.request = "妻子的请求是：" + _request;
    break;
    case 3:
    this.request = "母亲的请求是：" + _request;
    }
    }
    //获得自己的状况
    public int getType(){
        return this.type;
    }
    //获得妇女的请求
    public String getRequest(){
        return this.request;
    }
}

在主类中进行调用时，可以先设置：

    //设置请示顺序
    father.setNext(husband);
    husband.setNext(son);

让父亲先进行处理即可。能处理就处理掉，不能处理也已经设置好下一个来处理的人了，那么问题就简单了，这就是责任链模式啦。下面看一下其通用的类图：

当然这个模式可以融合模版方法模式。做下改善：

通过融合模版方法模式，各个实现类只要关注的自己业务逻辑就成了，至于说什么事要自己处理，那就让父类去决定好了，也就是说父类实现了请求传递的功能，子类实
现请求的处理，符合单一职责法则。

总结：

责任链与广播链对比：
（1）受众数量不同。观察者广播链式可以 1：N 的方式广播，而责任链则要求是的 1:1 的传递，必然有一个且只有一个类完成请求的处理；

（2）请求内容不同。观察者广播链中的信息可以在传播中改变，但是责任链中的请求是不可改变的；

（3）处理逻辑不同。观察者广播链主要用于触发联动动作，而责任链则是对一个类型的请求按照既定的规则进行处理。