设计模式之（十四）责任链模式（Chain of Responsibility）

　　在业务场景中，有很多是需要审批的。审核方式还可能常常发生变化，而责任链模式就是为了解决这种场景的情况的。

　　责任链模式定义：十多个对象都有机会处理请求，从而避免发送者和接受者之间的耦合关系。讲这些对象连成一条链，并沿着这条链传送这个请求，直到有一个对象处理他为止。　

　　责任链模式的思想就是把处理请求的处理都拆开，一个处理逻辑封装成一个小颗粒类，在需要使用的时候就可以按照业务需要排序起来处理，就像一个链条。但是在这个过程中可能走完了也没有得到处理，这就需要给出一个默认的处理，而给出处理结果。接下来看看此模式的类图：

从这个图里可以看出来，这个模式和递归算法很大关系，接下来通过一个例子来加深对此模式的理解。

 /***
  * 处理类的抽象类
  * @author pwq
  */
 public abstract class Handle {
     protected Handle successor = null;

     public void setSuccessor(Handle successor) {
         this.successor = successor;
     }

     public abstract    String handleFeeRequest(String user,double fee);

 }

 /***
  * 其中一个处理逻辑类
  * @author pwq
  */
 public class ProjectManager extends Handle {

     @Override
     public String handleFeeRequest(String user, double fee) {
         // TODO Auto-generated method stub
         String str ="" ;
         if(fee < 500){
             if("小李".equals(user)){
                 str = "项目经理同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
             else{
                 str =  "项目经理不同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
         }
         else{
             if(successor != null)
                 str = successor.handleFeeRequest(user, fee);
         }
         return str;
     }
 }

 /***
  * 处理逻辑类
  * @author pwq
  *
  */
 public class DeptManager extends Handle {

     @Override
     public String handleFeeRequest(String user, double fee) {
         // TODO Auto-generated method stub
         String str ="" ;
         if(fee < 1000){
             if("小李".equals(user)){
                 str = "部门经理同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
             else{
                 str =  "部门经理不同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
         }
         else{
             if(successor != null)
                 str = successor.handleFeeRequest(user, fee);
         }
         return str;
     }
 }

DeptManager 处理逻辑类

 public class GeneralManager  extends Handle {

     @Override
     public String handleFeeRequest(String user, double fee) {
         // TODO Auto-generated method stub
         String str ="" ;
         if(fee >= 1000){
             if("小李".equals(user)){
                 str = "总经理同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
             else{
                 str =  "总经理不同意"+user+"申请的聚餐费用 "+ fee +" 元";
             }
         }
         else{
             if(successor != null)
                 str = successor.handleFeeRequest(user, fee);
         }
         return str;
     }
 }

GeneralManager 处理逻辑类

 public class Client {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Handle h1=new ProjectManager();
         Handle h2 = new DeptManager();
         Handle h3 = new GeneralManager();

         h1.setSuccessor(h2);
         h2.setSuccessor(h3);

         String str = h1.handleFeeRequest("万小弟", 600);
         System.out.println(str);
         String str2 = h1.handleFeeRequest("彭大哥", 1800);
         System.out.println(str2);
         String str3 = h1.handleFeeRequest("小李", 400);
         System.out.println(str3);
     }
 }

 /*****************************************************/

 部门经理不同意万小弟申请的聚餐费用 600.0 元
 总经理不同意彭大哥申请的聚餐费用 1800.0 元
 项目经理同意小李申请的聚餐费用 400.0 元

　　通过这个例子分析处理类的写法，如果从抽象类来看的话，就是递归算法来达到让每个逻辑都有机会处理请求的。要类里面要定义下个环节处理的逻辑类变量，在使用的时候通过这个设置来组成处理的链。

　　例子展示的是责任链，也就是典型的审批的流程这样场景。还有另外一种用法，就是功能链，功能链就是把从多功能拆分到单一功能类中，可以根据需要来调用，相对来说更灵活，也便于复用。

责任链的有点和缺点

　　优点就是：

　　    1、把复杂功能拆分处理，让每个类只是负责一个处理逻辑。复用性更好，组合更加灵活。

　　    2、请求和处理类分开，实现低耦合，更加利于扩展。

　　缺点：小颗粒类大幅膨胀。

模式的本质

　　分离职责，动态组合