《Java设计模式》之责任链模式

　责任链模式是一种对象的行为模式。在责任链模式里，非常多对象由每个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的client并不知道链上的哪一个对象终于处理这个请求，这使得系统能够在不影响client的情况下动态地又一次组织和分配责任。

从击鼓传花谈起

　　击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的。以示公正。開始击鼓时，花束就開始依次传递，鼓声一落，假设花束在某人手中。则该人就得饮酒。

　　比方说，贾母、贾赦、贾政、贾宝玉和贾环是五个參加击鼓传花游戏的传花者。他们组成一个环链。

击鼓者将花传给贾母，開始传花游戏。花由贾母传给贾赦，由贾赦传给贾政。由贾政传给贾宝玉，又贾宝玉传给贾环。由贾环传回给贾母，如此往复，例如以下图所看到的。当鼓声停止时，手中有花的人就得运行酒令。

　　击鼓传花便是责任链模式的应用。责任链可能是一条直线、一个环链或者一个树结构的一部分。

责任链模式的结构

　　以下使用了一个责任链模式的最简单的实现。

　　责任链模式涉及到的角色例如以下所看到的：

　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。

假设须要，接口能够定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了详细子类对下家的引用。抽象方法handleRequest()规范了子类处理请求的操作。

　　●　　详细处理者(ConcreteHandler)角色：详细处理者接到请求后，能够选择将请求处理掉，或者将请求传给下家。

因为详细处理者持有对下家的引用。因此。假设须要。详细处理者能够訪问下家。

源码

　　抽象处理者角色

public abstract class Handler {
    
    /**
     * 持有后继的责任对象
     */
    protected Handler successor;
    /**
     * 示意处理请求的方法。尽管这个示意方法是没有传入參数的
     * 但实际是能够传入參数的。依据详细须要来选择是否传递參数
     */
    public abstract void handleRequest();
    /**
     * 取值方法
     */
    public Handler getSuccessor() {
        return successor;
    }
    /**
     * 赋值方法，设置后继的责任对象
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    
}

　　详细处理者角色

public class ConcreteHandler extends Handler {
    /**
     * 处理方法。调用此方法处理请求
     */
    @Override
    public void handleRequest() {
        /**
         * 推断是否有后继的责任对象
         * 假设有。就转发请求给后继的责任对象
         * 假设没有，则处理请求
         */
        if(getSuccessor() != null)
        {            
            System.out.println("放过请求");
            getSuccessor().handleRequest();            
        }else
        {            
            System.out.println("处理请求");
        }
    }

}

　　client类

public class Client {

    public static void main(String[] args) {
        //组装责任链
        Handler handler1 = new ConcreteHandler();
        Handler handler2 = new ConcreteHandler();
        handler1.setSuccessor(handler2);
        //提交请求
        handler1.handleRequest();
    }

}

　　能够看出，client创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后client将请求传递给第一个处理者对象。

　　因为本演示样例的传递逻辑很easy：仅仅要有下家。就传给下家处理。假设没有下家。就自行处理。因此，第一个处理者对象接到请求后，会将请求传递给第二个处理者对象。

因为第二个处理者对象没有下家，于是自行处理请求。活动时序图例如以下所看到的。

使用场景

　　来考虑这样一个功能:申请聚餐费用的管理。

　　非常多公司都是这种福利。就是项目组或者是部门能够向公司申请一些聚餐费用，用于组织项目组成员或者是部门成员进行聚餐活动。

　　申请聚餐费用的大致流程通常是：由申请人先填写申请单。然后交给领导审批，假设申请批准下来，领导会通知申请人审批通过，然后申请人去財务领取费用。假设没有批准下来。领导会通知申请人审批未通过。此事也就此作罢。

　　不同级别的领导，对于审批的额度是不一样的，比方，项目经理仅仅能审批500元以内的申请；部门经理能审批1000元以内的申请；而总经理能够审核随意额度的申请。

　　也就是说。当某人提出聚餐费用申请的请求后，该请求会经由项目经理、部门经理、总经理之中的某一位领导来进行对应的处理，可是提出申请的人并不知道终于会由谁来处理他的请求。一般申请人是把自己的申请提交给项目经理。也许最后是由总经理来处理他的请求。

　　能够使用责任链模式来实现上述功能：当某人提出聚餐费用申请的请求后。该请求会在 项目经理—〉部门经理—〉总经理 这样一条领导处理链上进行传递，发出请求的人并不知道谁会来处理他的请求，每一个领导会依据自己的职责范围，来推断是处理请求还是把请求交给更高级别的领导。仅仅要有领导处理了，传递就结束了。

　　须要把每位领导的处理独立出来。实现成单独的职责处理对象。然后为它们提供一个公共的、抽象的父职责对象，这样就能够在client来动态地组合职责链。实现不同的功能要求了。

源码

　　抽象处理者角色类

public abstract class Handler {
    /**
     * 持有下一个处理请求的对象
     */
    protected Handler successor = null;
    /**
     * 取值方法
     */
    public Handler getSuccessor() {
        return successor;
    }
    /**
     * 设置下一个处理请求的对象
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    /**
     * 处理聚餐费用的申请
     * @param user    申请人
     * @param fee    申请的钱数
     * @return        成功或失败的详细通知
     */
    public abstract String handleFeeRequest(String user , double fee);
}

　　详细处理者角色

public class ProjectManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //项目经理权限比較小，仅仅能在500以内
        if(fee < 500)
        {
            //为了測试，简单点，仅仅允许张三的请求
            if("张三".equals(user))
            {
                str = "成功：项目经理允许【" + user + "】的聚餐费用，金额为" + fee + "元";    
            }else
            {
                //其它人一律不允许
                str = "失败：项目经理不允许【" + user + "】的聚餐费用，金额为" + fee + "元";
            }
        }else
        {
            //超过500，继续传递给级别更高的人处理
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

public class DeptManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //部门经理的权限仅仅能在1000以内
        if(fee < 1000)
        {
            //为了測试，简单点。仅仅允许张三的请求
            if("张三".equals(user))
            {
                str = "成功：部门经理允许【" + user + "】的聚餐费用，金额为" + fee + "元";    
            }else
            {
                //其它人一律不允许
                str = "失败：部门经理不允许【" + user + "】的聚餐费用。金额为" + fee + "元";
            }
        }else
        {
            //超过1000。继续传递给级别更高的人处理
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

public class GeneralManager extends Handler {

    @Override
    public String handleFeeRequest(String user, double fee) {
        
        String str = "";
        //总经理的权限非常大。仅仅要请求到了这里，他都能够处理
        if(fee >= 1000)
        {
            //为了測试，简单点，仅仅允许张三的请求
            if("张三".equals(user))
            {
                str = "成功：总经理允许【" + user + "】的聚餐费用。金额为" + fee + "元";    
            }else
            {
                //其它人一律不允许
                str = "失败：总经理不允许【" + user + "】的聚餐费用，金额为" + fee + "元";
            }
        }else
        {
            //假设还有后继的处理对象。继续传递
            if(getSuccessor() != null)
            {
                return getSuccessor().handleFeeRequest(user, fee);
            }
        }
        return str;
    }

}

　　client类

public class Client {

    public static void main(String[] args) {
        //先要组装责任链
        Handler h1 = new GeneralManager();
        Handler h2 = new DeptManager();
        Handler h3 = new ProjectManager();
        h3.setSuccessor(h2);
        h2.setSuccessor(h1);
        
        //開始測试
        String test1 = h3.handleFeeRequest("张三", 300);
        System.out.println("test1 = " + test1);
        String test2 = h3.handleFeeRequest("李四", 300);
        System.out.println("test2 = " + test2);
        System.out.println("---------------------------------------");
        
        String test3 = h3.handleFeeRequest("张三", 700);
        System.out.println("test3 = " + test3);
        String test4 = h3.handleFeeRequest("李四", 700);
        System.out.println("test4 = " + test4);
        System.out.println("---------------------------------------");
        
        String test5 = h3.handleFeeRequest("张三", 1500);
        System.out.println("test5 = " + test5);
        String test6 = h3.handleFeeRequest("李四", 1500);
        System.out.println("test6 = " + test6);
    }

}

执行结果例如以下所看到的：

责任链模式是对象的行为模式。

使多个对象都有机会处理请求，从而避免请求的发送者和接受者直接的耦合关系。

将这些对象连成一条链。沿着这条链传递该请求，直到有一个对象处理它为止。责任链模式强调的是每个对象及其对下家的引用来组成一条链。利用这样的方式将发送者和接收者解耦，类图例如以下：

通过上图能够看出责任链模式有两个角色：

抽象处理者（Handler）角色 ：定义一个请求的接口。假设须要能够定义个一个方法用来设定和返回下家对象的引用。

详细处理者（ConcreteHandler）角色 ：假设能够处理就处理请求，假设不能处理，就把请求传给下家，让下家处理。

也就是说它处理自己能处理的请求且能够訪问它的下家。

上述模式的測试代码例如以下：

package chainOfResp;
/**
 * 
 *作者：alaric
 *时间：2013-8-17上午11:01:58
 *描写叙述：抽象处理角色
 */
public abstract class Handler {

  protected Handler successor;
  /**
   * 
   *作者：alaric
   *时间：2013-8-17上午11:04:22
   *描写叙述：处理方法
   */
  public abstract void handlerRequest(String condition);
  
  
  public Handler getSuccessor() {
    return successor;
  }
  public void setSuccessor(Handler successor) {
    this.successor = successor;
  }	
  
}

package chainOfResp;
/**
 * 
 *作者：alaric
 *时间：2013-8-17上午11:25:54
 *描写叙述：详细处理角色
 */
public class ConcreteHandler1 extends Handler {

  @Override
  public void handlerRequest(String condition) {
    // 假设是自己的责任。就自己处理。负责传给下家处理
    if(condition.equals("ConcreteHandler1")){
      System.out.println( "ConcreteHandler1 handled ");
      return ;
    }else{
      System.out.println( "ConcreteHandler1 passed ");
      getSuccessor().handlerRequest(condition);
    }
  }

}

package chainOfResp;
/**
 * 
 *作者：alaric
 *时间：2013-8-17上午11:25:54
 *描写叙述：详细处理角色
 */
public class ConcreteHandler2 extends Handler {
  
  @Override
  public void handlerRequest(String condition) {
    // 假设是自己的责任，就自己处理，负责传给下家处理
    if(condition.equals("ConcreteHandler2")){
      System.out.println( "ConcreteHandler2 handled ");
      return ;
    }else{
      System.out.println( "ConcreteHandler2 passed ");
      getSuccessor().handlerRequest(condition);
    }
  }

}

package chainOfResp;
/**
 * 
 *作者：alaric
 *时间：2013-8-17上午11:25:54
 *描写叙述：详细处理角色
 */
public class ConcreteHandlerN extends Handler {

  /**
   * 这里如果n是链的最后一个节点必须处理掉
   * 在实际情况下。可能出现环，或者是树形。
   * 这里并不一定是最后一个节点。
   * 
   */
  @Override
  public void handlerRequest(String condition) {

    System.out.println( "ConcreteHandlerN handled");
    
  }

}

package chainOfResp;
/**
 * 
 *作者：alaric
 *时间：2013-8-17上午10:59:06
 *描写叙述：測试类
 */
public class Client {

  /**
   *作者：alaric
   *时间：2013-8-17上午10:58:58
   *描写叙述：
   */
  public static void main(String[] args) {
  
    Handler handler1 = new ConcreteHandler1();
    Handler handler2 = new ConcreteHandler2();
    Handler handlern = new ConcreteHandlerN();
    
    //链起来
    handler1.setSuccessor(handler2);
    handler2.setSuccessor(handlern);
    
    //如果这个请求是ConcreteHandler2的责任
    handler1.handlerRequest("ConcreteHandler2");
    
    
  }

}

举这样一个样例，在玩具工厂的生产车间，流水线就是一条责任链，假如一个玩具飞机有外壳装配员，引擎装配员，螺旋桨装配员。模型包装员组成。当这个物件飞机流到谁那里，谁就负责安装他负责的这一部分，这部分安装完毕后流到下一个环节，知道全部环境完毕。这个是一生成的责任链。另一个质量检測链，质量检測也分多部。外壳检測，引擎检測。螺旋桨检測。包装检測。当产品留到检測员那里检測自己负责的那一块，假设有问题直接拎出来，假设没问题则传给下一个检測员，直到全部检測完毕。这两个都是责任链。可是差别是，生成责任链每一个人都会处理。并处理一部分；而质量检測责任链经过推断。要么处理掉，要么不处理流下去。这就是责任链的两种分类。后一种叫做纯的责任链，前一种叫做不纯的责任链，纯的责任链在实际应用中非常少存在，常见的为不纯的责任链。上面的模型是模拟纯的责任链来处理的。

责任链模式在现实中使用的非常多，常见的就是OA系统中的工作流。在java中的实际应用有Servlet中的过滤器（Filter），Struts2的拦截器（Interceptor）。Struts2本身在Servlet中也是以Filter的形式出现的，所以Struts2的结构图中。也能够明显看出Filter和Interceptor这两条链的存在。

能够看出它们每一个节点都能够做一些事情。所以不算一个纯的责任链。

在上面提到了OA系统。那么我们再模拟一下OA系统中请假审批流程，假如员工直接上司为小组长，小组长直接上司项目经理。项目经理直接上司部门经理。部门经理直接上司总经理。公司规定请假审批例如以下：

请假时间为t,时间单位day，简写d：

t< 0.5d。小组长审批；

t>=0.5d,t<2,项目经理审批。

t>=2,t<5部门经理审批；

t>=5总经理审批；

审批时序图例如以下：

用代码描写叙述：

package chainOfResp.example;
/**
 * 
 *作者：alaric
 *时间：2013-8-17下午1:02:51
 *描写叙述：审批处理抽象类
 */
public abstract class Handler {

  protected Handler handler;

  /**
   * 
   *作者：alaric
   *时间：2013-8-17下午1:07:40
   *描写叙述：审批
   */
  public abstract boolean approve(double day);
  
  public Handler getHandler() {
    return handler;
  }
  public void setHandler(Handler handler) {
    this.handler = handler;
  }
  
}

package chainOfResp.example;


public class GroupLeader extends Handler {

  @Override
  public boolean approve(double day) {
    if(day<0.5){
      System.out.println("小组长审批通过");
      return true;
    }else {
      System.out.println("小组长传给了他的上司");
      return getHandler().approve(day);
    }
  }


}

package chainOfResp.example;


public class ProjectManager extends Handler {

  @Override
  public boolean approve(double day) {
    if(day<2){
      System.out.println("项目经理审批通过");
      return true;
    }else {
      System.out.println("项目经理传给了他的上司");
      return getHandler().approve(day);
    }
  }


}

package chainOfResp.example;


public class DepartmentManager extends Handler {

  @Override
  public boolean approve(double day) {
    if(day<5){
      System.out.println("部门经理审批通过");
      return true;
    }else {
      System.out.println("部门经理传给了他的上司");
      return getHandler().approve(day);
    }
  }


}

package chainOfResp.example;


public class CEO extends Handler {

  @Override
  public boolean approve(double day) {
      System.out.println("部门经理审批通过");
      return true;
    
  }

}

package chainOfResp.example;
/**
 * 
 *作者：alaric
 *时间：2013-8-17下午12:54:51
 *描写叙述：測试类。首先来创建责任链，然后发出请求模拟员工来请假
 */
public class Client {

  /**
   *作者：alaric
   *时间：2013-8-17下午12:54:44
   *描写叙述：
   */
  public static void main(String[] args) {

    //创建节点
    GroupLeader gl = new GroupLeader();
    ProjectManager pm = new ProjectManager();
    DepartmentManager dm = new DepartmentManager();
    CEO ceo = new CEO();
    //建立责任链
    gl.setHandler(pm);
    pm.setHandler(dm);
    dm.setHandler(ceo);
    
    //向小组长发出申请，请求审批4天的假期
    gl.approve(4D);
    

  }

}

执行结果：

小组长传给了他的上司

项目经理传给了他的上司

部门经理审批通过

这里模拟的是一个理想的状态，所以是一个纯的责任链。在实际其中，可能小组长签字，项目经理签字...一堆的签字，而不是不參与请求的处理。

责任链模式的长处是调用者不需知道详细谁来处理请求。也不知道链的详细结构。减少了节点域节点的耦合度。可在执行时动态改动链中的对象职责，增强了给对象指派职责的灵活性。缺点是没有明白的接收者。可能传到链的最后，也没得到正确的处理。

本文借鉴：

http://www.cnblogs.com/java-my-life/archive/2012/05/28/2516865.html

http://www.tuicool.com/articles/RJvARj