责任链模式--ResponseChain

　　模拟场景：在一个正规的公司中都是存在着健全的请假或者提薪规则的，以请假为例。如果员工在节假日或者平常时需要请假的时候，如果是两天内的话找项目经理请假即可。而超过两天的经理无权受理。五天内的找总监，超过五天总监无权受理。八天内找总经理申请。。。

　　现在我们将上述的情景生成对应的类文件。首先，肯定存在员工类（Worker）、经理类（Manager）、总监类（Director）、总经理类（GeneralManager）。很明显，这里存在三个管理者类，有着相同的特性，都是可以对员工的请求进行回应。那么这个时候就可以抽象出一个ManageHandler接口，定义一个方法来受理员工的请求。当然也可以是抽象类。还有，一家公司不可能只有一名员工，所以定义一个IWorker接口，所有的员工都有一样的动作，没有特权。那么除了以上的类，是否还应该存在一个请求类（Request）呢？因为请求并不仅仅是属于某个员工的，可能两三个员工有着相同的请求呢？

　　现在开始构建类

IWorker

package com.zqz.dp.responsechain1.worker;
import com.zqz.dp.responsechain1.manage.ManageHandler;
import com.zqz.dp.responsechain1.request.Request;
/**
 * @author Qin
 * 员工的接口，所有的员工都有同一的属性
 */
public interface IWorker {
    public String getName();    //取得员工的名字
    public void setRequest(Request request); // 设置员工的请求
    public Request getRequest(); // 得到员工的请求
    public void sendRequest(ManageHandler manageHandler); // 向管理者发出请求
}

Worker

package com.zqz.dp.responsechain1.worker;
import com.zqz.dp.responsechain1.manage.ManageHandler;
import com.zqz.dp.responsechain1.request.Request;
/**
 * @author Qin 
 * 员工类，员工中存放名字（String:name），员工的请求（Request:request）
 */
public class Worker implements IWorker {
    private String name; // 员工的名字
    private Request request = null; // 员工的请求
    public Worker(String name) { // 构造方法赋值
        this.name = name;
    }
    @Override
    public void setRequest(Request request) { // 设置员工的请求
        this.request = request;
    }
    @Override
    public Request getRequest() { // 取得员工的请求
        return request;
    }
    @Override
    public void sendRequest(ManageHandler manager) { // 向管理者发出请求
        manager.handlerMessage(this);
    }
    @Override
    public String getName() { // 取得员工姓名
        return this.name;
    }
}

Request

package com.zqz.dp.responsechain1.request;
/**
 * @author Qin 请求类，包含请求的类型和数量
 */
public class Request {
    private String requestType; // 请求的类型
    private int requestNum; // 请求的数量
    public Request(String requestType, int requestNum) { // 构造方法赋值
        this.requestType = requestType;
        this.requestNum = requestNum;
    }
    /**
     * getter、setter方法
     */
    public String getRequestType() {
        return requestType;
    }
    public int getRequestNum() {
        return requestNum;
    }
}

ManageHandler

package com.zqz.dp.responsechain1.manage;
import com.zqz.dp.responsechain1.worker.IWorker;
/**
 * @author Qin
 * 管理者类，所有的管理者要实现该接口
 */
public interface ManageHandler {
    void handlerMessage(IWorker worker);        //做出相应的动作，指明是哪个员工发出的请求
}

Manager

package com.zqz.dp.responsechain1.manage;
import com.zqz.dp.responsechain1.worker.IWorker;
/**
 * @author Qin 
 * 经理类，经理可以做出相应的响应，实现接口中的方法
 */
public class Manager implements ManageHandler {
    private String name; // 经理的名字
    private IWorker worker; // 提交申请的员工
    public Manager(String name) { // 构造方法赋值
        this.name = name;
    }
    @Override
    public void handlerMessage(IWorker worker) { // 处理员工的请求
        this.worker = worker; // 指明员工对象
        String requestType = this.worker.getRequest().getRequestType(); // 得到员工的请求类型
        int requestNum = this.worker.getRequest().getRequestNum(); // 得到员工的请求数量
        if ("请假".equals(requestType) && requestNum <= 2) { // 表示请假两天内可以进行决策
            System.out.println(this.name + "说：同意〖" + worker.getName() + "〗"
                    + requestType + requestNum + "天"); // 做出决定
        } else {
            System.out.println(this.name + "说：我无权处理");// 做出决定
        }
    }
}

Director

package com.zqz.dp.responsechain1.manage;
import com.zqz.dp.responsechain1.worker.IWorker;
/**
 * @author Qin
 * 总监类，总监可以做出相应的响应，实现接口中的方法
 */
public class Director implements ManageHandler {
    private String name;    //总监的名字
    private IWorker worker;    //发送请求的员工    
    public Director(String name) {    //构造方法赋值
        this.name=name;
    }
    @Override
    public void handlerMessage(IWorker worker) {    //处理员工的请求
        this.worker=worker;        //赋值
        String requestType=this.worker.getRequest().getRequestType();    //得到员工请求的类型
        int requestNum=this.worker.getRequest().getRequestNum();    //得到员工请求的数量
        if("请假".equals(requestType)&&requestNum<=5){    // 表示请假五天内可以进行决策
            System.out.println(this.name+"说：同意〖"+worker.getName()+"〗"+requestType+requestNum+"天");
        }else{
            System.out.println(this.name+"说：我无权处理");
        }
    }
}

GeneralManager

package com.zqz.dp.responsechain1.manage;
import com.zqz.dp.responsechain1.worker.IWorker;
/**
 * @author Qin
 * 总经理类，总经理可以做出相应的响应，实现接口中的方法
 */
public class GeneralManager implements ManageHandler {
    private String name;    //总经理的名字
    private IWorker worker;    //请求的员工
    public GeneralManager(String name) {    //构造方法赋值
        this.name=name;
    }
    @Override
    public void handlerMessage(IWorker worker) {    //处理员工的请求
        this.worker=worker;        //赋值
        String requestType=this.worker.getRequest().getRequestType();    //得到请求的类型
        int requestNum=this.worker.getRequest().getRequestNum();        //得到请求的数量
        if("请假".equals(requestType)&&requestNum<=8){    //表示请假八天内可以受理
            System.out.println(this.name+"说：同意〖"+worker.getName()+"〗"+requestType+requestNum+"天");
        }else{
            System.out.println(this.name+"说：我无权处理");
        }
    }
}

Client

package com.zqz.dp.responsechain1.client;
import com.zqz.dp.responsechain1.manage.Director;
import com.zqz.dp.responsechain1.manage.GeneralManager;
import com.zqz.dp.responsechain1.manage.Manager;
import com.zqz.dp.responsechain1.request.Request;
import com.zqz.dp.responsechain1.worker.Worker;
/**
 * @author Qin
 * 客户端，员工发出请求，管理者进行回应
 */
public class Client {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Worker worker=new Worker("张三");        //得到员工对象
        Request request=new Request("请假",3);    //得到请求对象
        worker.setRequest(request);            //把请求设置到员工对象中，表示员工有该请求
        Manager manager=new Manager("经理");        //经理类
        Director director=new Director("总监");    //总监类
        GeneralManager generalManager=new GeneralManager("总经理");//总经理类
        worker.sendRequest(manager);    //员工向经理发送请求
        worker.sendRequest(director);//员工向总监发送请求
        worker.sendRequest(generalManager);//员工向总经理发送请求
    }
}

　　按上面的操作确实可以完成了操作，但是上面的代码是不合适的。因为该员工同时向三位领导发出了请求。或许有读者会反馈说可以先进行判断，如果再决定向那个领导发出请求。其实这也是不合适的，这样员工和领导的耦合度太强了。一般请假的时候，最好只向一个领导发出请求，该领导无法受理的时候就交给其他领导。记住，是领导交给其他领导，而不是你交给其他领导。这样就降低了耦合度。想想，如果是员工自己请求其他领导，那高级领导是否会接触一大堆底层员工呢？很明显这样不合适，而且有低级领导向高级领导提出申请，或许帮你美言几句机会更大了。

　　以上说的就是责任链模式，底层对象只和另一个对象进行交互，具体是哪个对象来处理该请求，底层对象不关心。在这里，是哪个领导批准的员工不关心，员工关心的是请求能否通过。

　　细心的读者会发现，上面的操作中，Manager、Director、GeneralManager类中共同的代码太多了，这个时候会发现把接口修改成类来继承的话会减少好多重复代码。细心观察，在HandlerMessage中，不同的只是管理者允许请假的天数不同，还有各个管理者的反馈信息不同而已。具体的天数可以通过否则方法进行赋值，也就是说在实例化管理者的时候，就给定该管理员有多少天的决定权。其实这个时候就可以使用模板设计模式了，把HandlerMessage方法定义为final，防止子类进行覆写，然后定义一个抽象的response方法，表示每个管理者的反馈消息。

　　为了达到解耦和的操作，在ManageHandler类中，采用链表的方式，定义一个ManageHandler类型的nextManager对象，表示的是管理者的直属领导，当管理者无权受理的时候就交给直属领导操作。

　　修改部分模块的代码，如下

ManageHandler

package com.zqz.dp.responsechain2.manage;
import com.zqz.dp.responsechain2.worker.IWorker;
/**
 * @author Qin
 * 管理者类，所有的管理者要实现该接口
 */
public abstract class ManageHandler {
    private IWorker worker;        //发出请求的员工
    private String name;        //管理者的名字
    private int num;            //管理者最多可以处理的数量（请假天数）
    private ManageHandler nextManager;    //设置管理者的直属领导
    public String getName() {        //得到领导的名字
        return name;    
    }
    public void setNextManager(ManageHandler nextManager) {
        this.nextManager = nextManager;
    }
    public ManageHandler(String name, int num) {    //构造方法赋值
        this.name = name;
        this.num = num;
    }
    public abstract void response(IWorker worker);    //领导作出反馈
    public final void handlerMessage(IWorker worker){        //做出相应的动作，指明是哪个员工发出的请求，final关键字表示不能进行覆写
        this.worker = worker; // 指明员工对象
        String requestType = this.worker.getRequest().getRequestType(); // 得到员工的请求类型
        int requestNum = this.worker.getRequest().getRequestNum(); // 得到员工的请求数量
        if ("请假".equals(requestType) && requestNum <= this.num) { // 表示请假两天内可以进行决策
            this.response(worker);// 做出决定
        } else {
            if(this.nextManager!=null){         //有直属领导
                System.out.println(this.name+"说：我无权受理，要请示"+this.nextManager.getName());
                this.nextManager.handlerMessage(worker);    //交给领导去操作
            }else{
                System.out.println(this.name+"没回复，无法不通过...");
            }
        }
    }
}

Manager

package com.zqz.dp.responsechain2.manage;
import com.zqz.dp.responsechain2.worker.IWorker;
/**
 * @author Qin 
 * 经理类，经理可以做出相应的响应，实现接口中的方法
 */
public class Manager extends ManageHandler {
    public Manager(String name,int num) { // 构造方法赋值
        super(name,num);
    }
    @Override
    public void response(IWorker worker) {        //经理反馈
        System.out.println(this.getName()+"说：鉴于〖"+worker.getName()+"〗工作认真，所以批准...");
    }
}

Director

package com.zqz.dp.responsechain2.manage;
import com.zqz.dp.responsechain2.worker.IWorker;
/**
 * @author Qin
 * 总监类，总监可以做出相应的响应，实现接口中的方法
 */
public class Director extends ManageHandler {
    public Director(String name,int num) { // 构造方法赋值
        super(name,num);
    }
    @Override
    public void response(IWorker worker) {    //总监反馈
        System.out.println(this.getName()+"说：〖"+worker.getName()+"〗表现还行，通过...");
    }
}

GeranalManager

package com.zqz.dp.responsechain2.manage;
import com.zqz.dp.responsechain2.worker.IWorker;
/**
 * @author Qin
 * 总经理类，总经理可以做出相应的响应，实现接口中的方法
 */
public class GeneralManager extends ManageHandler {
    public GeneralManager(String name,int num) { // 构造方法赋值
        super(name,num);
    }
    @Override
    public void response(IWorker worker) {    //总经理反馈
        System.out.println(this.getName()+"说：时间太长了，不能通过...");
    }
}

Client

package com.zqz.dp.responsechain2.client;
import com.zqz.dp.responsechain2.manage.Director;
import com.zqz.dp.responsechain2.manage.GeneralManager;
import com.zqz.dp.responsechain2.manage.Manager;
import com.zqz.dp.responsechain2.request.Request;
import com.zqz.dp.responsechain2.worker.Worker;
/**
 * @author Qin
 * 客户端，员工发出请求，管理者进行回应
 */
public class Client {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Worker worker=new Worker("张三");        //得到员工对象
        Request request=new Request("请假",8);    //得到请求对象
        worker.setRequest(request);            //把请求设置到员工对象中，表示员工有该请求
        Manager manager=new Manager("经理",2);        //经理类
        Director director=new Director("总监",5);    //总监类
        GeneralManager generalManager=new GeneralManager("总经理",8);//总经理类
        manager.setNextManager(director);        //设置经理的直属领导
        director.setNextManager(generalManager);    //设置总监的直属领导
        worker.sendRequest(manager);    //员工向经理发送请求
    }
}

　　上面就完成了责任链模式，而且还结合了模板设计模式。会发现，Client端的代码并没有修改很多，但是员工只是向经理发出了请求，并未向其他领导提出，却得到了其他领导的反馈消息，真正做到了解耦合。

　　责任链模式的定义：使多个对象都有机会去处理用户发出来的请求，从而避免了请求的发送者和接收和的耦合。将多个对象连成一条链，并沿着这条链传递该请求，最后得到接口。其实责任链模式跟链表的知识是一样的。

　　责任链模式中，要注意一下几点：一是定义一个对外开放的处理请求方法，如HandlerMessage。二是定义一个链的编排方法，如setNextManager。三是具体的处理类要定义自己的处理方法，和自己处理的等级。如response方法，构造方法传递num。

责任链模式的优点：

　　将请求和处理分开来，请求不需要知道谁处理了该请求。

责任链模式的缺点：

　　1、  性能不高，每次都要从链头开始查找，如果处理对象再链尾的话，性能较差。

　　2、  当链表较长时，调试不方便。注意：尽量避免长链的情况。

责任链模式的拓展：

　　学习jsp的同学应该对Filter不陌生吧，当有多个过滤器的时候，就是形成了一条过滤器链。不同的是，过滤器会先把传递进来的数据进行拦截，进行一系列的操作，再交给下一个过滤器。当与数据库进行交互之后，返回的数据会先结果最后一个过滤器，逆着被过滤直到调用第一个过滤器。

　　比如，现在有一个字符串：”request msg…”。有两个过滤器，在接收的过程中被修改为” request msg...first filter...second filter...”。经数据库操作（只是模拟）后response的值为“response msg…”反馈回来的时候得到的” response msg。。。Second Filter。。。First Filter。。。”。

　　在转换为类文件中，最重要的是过滤器链的设置。过滤器链其实也是执行过滤的操作，不同的是过滤器链存放了好多个过滤器。过滤的时候取出每一个进行过滤。而调用每一个过滤器的时候，除了添加该过滤器链进行操作，其他的实际上还是调用过滤器链，循环取出其他过滤器。所以要把过滤器链传递到多个过滤器中。

　　因此定义一个过滤器接口，有一个方法，方法中存放了过滤器链。所有的过滤器，包括过滤器链都要实现该接口。

Filter

package com.zqz.dp.webfilterchain.filter;
import com.zqz.dp.webfilterchain.request.Request;
import com.zqz.dp.webfilterchain.response.Response;
/**
 * @author Qin
 * 定义一个过滤链的接口，所有的过滤操作都有同样的特性
 */
public interface Filter {
    void doFilter(Request request,Response response,FilterChain chain);        //传递过滤器链实例，每次过滤最终都是调用过滤器链进行过滤的操作
}

FilterChain

package com.zqz.dp.webfilterchain.filter;
import java.util.ArrayList;
import java.util.List;
import com.zqz.dp.webfilterchain.request.Request;
import com.zqz.dp.webfilterchain.response.Response;
/**
 * @author Qin
 * 过滤链，用list来接收过滤链，把所有需要的过滤添加到list中，进行操作的时候取出list的过滤器进行过滤
 */
public class FilterChain implements Filter{
    private int index=0;    //定义一个脚标，表示是否已达到list容器的大小
    private List<Filter> filters=new ArrayList<Filter>();    //实例化一个list，来装载过滤器
    public void addFilter(Filter filter){    //添加过滤器到list中
        this.filters.add(filter);    //添加到容器中
    }
    @Override
    public void doFilter(Request request, Response response,FilterChain chain) {    //过滤的操作
        if(index!=this.filters.size()){    //容器中的过滤器还未完成取出
            Filter filter=this.filters.get(index);        //进行过滤的操作
            this.index++;
            if(this.index==this.filters.size()){    //如果过滤器已将请求过滤完毕
                response.getResponseMsg().append("response msg。。。");    //设置反馈的信息
            }
            filter.doFilter(request, response, chain);    //取出过滤器进行过滤的操作
        }
    }
}

FirstFilter

package com.zqz.dp.webfilterchain.filter;
import com.zqz.dp.webfilterchain.request.Request;
import com.zqz.dp.webfilterchain.response.Response;
/**
 * @author Qin
 * 第一个过滤器，表示进行过滤的操作
 */
public class FirstFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response,FilterChain chain) {
        request.getRequestMsg().append("first filter...");        //第一个过滤器接收的时候修改数据
        chain.doFilter(request, response, chain);    //执行下一个过滤器
        response.getResponseMsg().append("First Filter。。。");    //第一个过滤器接收后反馈
    }
}

SecondFilter

package com.zqz.dp.webfilterchain.filter;
import com.zqz.dp.webfilterchain.request.Request;
import com.zqz.dp.webfilterchain.response.Response;
/**
 * @author Qin
 * 第二个过滤器，表示进行过滤的操作
 */
public class SecondFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response,FilterChain chain) {
        request.getRequestMsg().append("second filter...");        //第二个过滤器接收的时候修改数据
        chain.doFilter(request, response, chain);        //执行下一个过滤器
        response.getResponseMsg().append("Second Filter。。。");    //第二个过滤器反馈信息
    }
}

Request

package com.zqz.dp.webfilterchain.request;
/**
 * @author Qin 请求类，包含请求信息
 */
public class Request {
    private StringBuffer requestMsg=new StringBuffer(); // 定义发送的请求信息，StringBuffer可以进行值的修改
    public Request() {   // 为了方便，构造方法初始化的时候进行赋值。
        this.requestMsg.append("request msg...");
    }
    public StringBuffer getRequestMsg() {    //得到StringBuffer对象
        return requestMsg;
    }
    @Override
    public String toString() { // 重写toStirng方法
        return this.requestMsg.toString();
    }
}

Response

package com.zqz.dp.webfilterchain.response;
/**
 * @author Qin 信息经过滤器之后的反馈结果
 */
public class Response {
    private StringBuffer responseMsg = new StringBuffer(); // 经过滤器过滤之后的返回结果
    public StringBuffer getResponseMsg() { // 得到StringBuffer对象
        return responseMsg;
    }
    @Override
    public String toString() { // 覆写toString
        return this.responseMsg.toString();
    }
}

Client

package com.zqz.dp.webfilterchain.client;
import com.zqz.dp.webfilterchain.filter.Filter;
import com.zqz.dp.webfilterchain.filter.FilterChain;
import com.zqz.dp.webfilterchain.filter.FirstFilter;
import com.zqz.dp.webfilterchain.filter.SecondFilter;
import com.zqz.dp.webfilterchain.request.Request;
import com.zqz.dp.webfilterchain.response.Response;
/**
 * @author Qin
 * 客户端，进行过滤的操作。
 */
public class Client {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Filter firstFilter=new FirstFilter();        //实例化第一个过滤器
        Filter secondFilter=new SecondFilter();        //实例化第二个过滤器
        FilterChain chain=new FilterChain();        //实例化过滤器链
        chain.addFilter(firstFilter);        //把第一个过滤器添加到过滤器链
        chain.addFilter(secondFilter);        //把第二个过滤器添加到过滤器链
        Request request=new Request();        //实例化一个request对象
        Response response=new Response();    //实例化一个response对象
        chain.doFilter(request,response, chain);    //开始执行过滤的操作
        System.out.println(request);    //输出
        System.out.println(response);    //输出
    }
}