设计模式（一）-责任链模式（Chain of Responsibility）

学习设计模式之前我们先来看一个这样的生活问题。申请聚餐费用。

这个我们平时的java怎么实现呢，看代码

public class FeeRequest {
    /**
     * 提交聚餐费用申请给项目经理
     * @param user 申请人
     * @param fee 申请费用
     * @return 成功或失败的具体通知
     */
    public String requestToProjectManager(String user,double fee){
        String str = "";    
        if(fee < 500){
            //项目经理的权限比较小，只能在500以内
            str = this.projectHandle(user, fee);
        }else if(fee < 1000){
            //部门经理的权限只能在1000以内
            str = this.depManagerHandle(user, fee);
        }else if(fee >= 1000){
            //总经理的权限很大，只要请求到了这里，他都可以处理
            str = this.generalManagerHandle(user, fee);
        }
        return str;
    }

    /**
     * 项目经理审批费用申请，参数、返回值和上面是一样的，省略了
     */
    private String projectHandle(String user, double fee) {
        String str = "";
        //为了测试，简单点，只同意小李的
        if("小李".equals(user)){
            str = "项目经理同意"+user+"聚餐费用"+fee+"元的请求";
        }else{
            //其他人一律不同意
            str = "项目经理不同意"+user+"聚餐费用"+fee+"元的请求";
        }
        return str;
    }

    /**
     * 部门经理审批费用申请，参数、返回值和上面是一样的，省略了
     */
    private String depManagerHandle(String user, double fee) {
        String str = "";
        //为了测试，简单点，只同意小李申请的
        if("小李".equals(user)){
            str = "部门经理同意"+user+"聚餐费用"+fee+"元的请求";
        }else{
            //其他人一律不同意
            str= "部门经理不同意"+user+"聚餐费用"+fee+"元的请求";
        }
        return str;
    }
                   /**
     * 总经理审批费用申请，参数、返回值和上面是一样的，省略了
     */
    private String generalManagerHandle(String user, double fee) 
    {
        String str = "";

        //为了测试，简单点，只同意小李的
        if("小李".equals(user)){
            str = "总经理同意"+user+"聚餐费用"+fee+"元的请求";
        }else{
            //其他人一律不同意
            str = "总经理不同意"+user+"聚餐费用"+fee+"元的请求";
        }
        return str;
    }

}

测试代码

public class Client {
    public static void main(String[] args) {
        FeeRequest request = new FeeRequest();

        //开始测试
        String ret1 = request.requestToProjectManager("小李", 300);
        System.out.println("the ret1="+ret1);       
        String ret2 = request.requestToProjectManager("小张", 300);
        System.out.println("the ret2="+ret2);

        String ret3 = request.requestToProjectManager("小李", 600);
        System.out.println("the ret3="+ret3);       
        String ret4 = request.requestToProjectManager("小张", 600);
        System.out.println("the ret4="+ret4);

        String ret5 = request.requestToProjectManager("小李", 1200);
        System.out.println("the ret5="+ret5);       
        String ret6 = request.requestToProjectManager("小张", 1200);
        System.out.println("the ret6="+ret6);
    }
}

经典的if else，是不是看的很亲切，这估计也是我们平时的做法，但是这样接受者多一个就要改很多.

在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显式指定，将必不可少地带来请求发送者与接受者的紧耦合。

如何使请求的发送者不需要指定具体的接受者？让请求的接受者自己在运行时决定来处理请求，从而使两者解耦。这就出现了我们的责任链设计模式。

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
——《设计模式》GoF

下面看看责任链设计模式

下面我们来看看通过责任链设计模式实现的代码。

Handler.java

/**
 * 定义职责对象的接口
 */
public abstract class Handler {
    /**
     * 持有下一个处理请求的对象
     */
    protected Handler successor = null;
    /**
     * 设置下一个处理请求的对象
     * @param successor 下一个处理请求的对象
     */
    public void setSuccessor(Handler successor){
        this.successor = successor;
    }
    /**
     * 处理聚餐费用的申请
     * @param user 申请人
     * @param fee 申请的钱数
     * @return 成功或失败的具体通知
     */
    public abstract String handleFeeRequest(String user,double fee);
}

ProjectManager.java

public class ProjectManager extends Handler{
    public String handleFeeRequest(String user, double fee) {
        String str = "";
        //项目经理的权限比较小，只能在500以内
        if(fee < 500){
            //为了测试，简单点，只同意小李的
            if("小李".equals(user)){
            str = "项目经理同意"+user+"聚餐费用"+fee+"元的请求";
            }else{
            //其他人一律不同意
        str = "项目经理不同意"+user+"聚餐费用"+fee+"元的请求";
            }
            return str;
        }else{
            //超过500，继续传递给级别更高的人处理
            if(this.successor!=null){
                return successor.handleFeeRequest(user, fee);
            }
        }
        return str;
    }
}

DepManager.java

public class DepManager extends Handler{
    public String handleFeeRequest(String user, double fee) {
        String str = "";
        //部门经理的权限只能在1000以内
        if(fee>=500 && fee < 1000){
            //为了测试，简单点，只同意小李申请的
            if("小李".equals(user)){
        str = "部门经理同意"+user+"聚餐费用"+fee+"元的请求";
            }else{
                //其他人一律不同意
        str = "部门经理不同意"+user+"聚餐费用"+fee+"元的请求";
            }
            return str;
        }else{
            //超过1000，继续传递给级别更高的人处理
            if(this.successor!=null){
                return this.successor.handleFeeRequest(user, fee);
            }
        }
        return str;
    }
}

GeneralManager.java

public class GeneralManager extends Handler{
    public String handleFeeRequest(String user, double fee) {
        String str = "";
        //总经理的权限很大，只要请求到了这里，他都可以处理
        if(fee >= 1000){
            //为了测试，简单点，只同意小李的
            if("小李".equals(user)){
            str = "总经理同意"+user+"聚餐费用"+fee+"元的请求";
            }else{
                //其他人一律不同意
        str = "总经理不同意"+user+"聚餐费用"+fee+"元的请求";
            }
            return str;
        }else{
            //如果还有后继的处理对象，继续传递
            if(this.successor!=null){
                return successor.handleFeeRequest(user, fee);
            }
        }
        return str;
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        //先要组装职责链       
        Handler h1 = new GeneralManager();
        Handler h2 = new DepManager();
        Handler h3 = new ProjectManager();
        h1.setSuccessor(h2);
        h2.setSuccessor(h3);    
        //开始测试
        String ret1 = h1.handleFeeRequest("小李", 300);
        System.out.println("the ret1="+ret1);   
        String ret2 = h1.handleFeeRequest("小张", 300);
        System.out.println("the ret2="+ret2);   
        String ret3 = h1.handleFeeRequest("小李", 600);
        System.out.println("the ret3="+ret3);   
        String ret4 = h1.handleFeeRequest("小张", 600);
        System.out.println("the ret4="+ret4);   
        String ret5 = h1.handleFeeRequest("小李", 1200);  
        System.out.println("the ret5="+ret5);   
        String ret6 = h1.handleFeeRequest("小张", 1200);
        System.out.println("the ret6="+ret6);}}

在这里实现的代码中，我们通过successor制定下的一个责任人，这就产生我们的责任链设计模式。
别以为我们没有见到过，学过struts2的都知道。filter chain ，interceptor chain，一个filter交给下一个，一个interceptor交给下一个。

下面再放一张责任链设计模式的序列图。

假如员工直接上司为小组长，小组长直接上司项目经理，项目经理直接上司部门经理，部门经理直接上司总经理。公司规定请假审批如下：
请假时间为t,时间单位day，简写d： t< 0.5d，小组长审批； t>=0.5d,t<2,项目经理审批；
t>=2,t<5部门经理审批； t>=5总经理审批； 审批时序图如下

大概就这样，不懂可留言讨论。