【设计模式】09-责任链模式

目录

 

什么是责任链模式

为什么要用责任链模式

责任链模式组成

---

什么是责任链模式

如名字所示，责任链模式旨在将各个处理对象连接成一条链，从而使其与请求者解耦，使请求者不必关心真正需要哪个具体对象做处理，只需要从责任链的统一入口进入，交予链上的各个对象处理，若处理对象不能完全处理，则交予链上的下一个对象来处理，直至整个处理流程结束。

 

为什么要用责任链模式

责任链的核心在“链”，使用责任链的好处在于不必将处理的条件和逻辑显示的在外部通过类似if else的跳转来处理，责任链的核心在于将流程封装在这条链上，而外部需要被处理的对象只需要从链的最顶层进入即可，不必知道真个处理流程是如何进行，甚至不必知道最终是由哪个具体对象所处理。从而解耦处理对象和被处理对象之间的逻辑。

从生活的角度可以类比各种审批流程。比如请假这么一个简单的流程，可能需要经过主管，部门经理，人事，老板整个流程审批下来。对于员工级别，可能低级别的只需要到主管处理就结束了，对于高级别的，主管处理不了，然后主管交由部门经理审批，如果部门经理有能力做出响应(审批)，则处理流程。若依然不能结束处理，则沿着责任链继续往下传递，直到整个流程处理结束。（无论最后请假是否成功，对于整个流程来说必然是全部处理完)。而请假者(请求处理对象)不需要关系整个处理流程的逻辑，不需要关心其对应级别应该找谁去审批。因为整个责任链已经把整套流程封装好。

 

责任链模式组成

抽象处理类

public abstract class AbstractHandler implements Handler {
   private AbstractHandler nextHandler;

   @Override
   public final String handleMessage(RequestObj requestObj) {
      String responseResult;
      if (this.getLevel() == requestObj.getLevel()) {
         //当前节点自己处理
         responseResult = response(requestObj);
      }
      else {
         //当前节点无法处理
         if (this.nextHandler != null) {
            //交由下一节点处理
            responseResult = this.nextHandler.handleMessage(requestObj);
         }
         else {
            //处理流程结束，无下一节点可用于处理请求，请求结束
            responseResult = "处理失败，请知晓";
         }
      }
      return responseResult;
   }

   public void setNextHandler(AbstractHandler nextHandler) {
      this.nextHandler = nextHandler;
   }

   protected abstract int getLevel();

   protected  abstract String response(RequestObj requestObj);
}

处理行为接口

public interface Handler {
   String handleMessage(RequestObj requestObj);
}

具体处理节点

public class ConcreteHandlerL1 extends AbstractHandler {
   @Override
   protected int getLevel() {
      return 1;
   }


   @Override
   protected String response(RequestObj requestObj) {
      return requestObj.getName()+" 您好！您的流程 L1 节点处理完成";
   }
}



public class ConcreteHandlerL2 extends AbstractHandler {
   @Override
   protected int getLevel() {
      return 2;
   }

   @Override
   protected String response(RequestObj requestObj) {
      return requestObj.getName()+" 您好！您的流程 L2 节点处理完成";
   }
}



public class ConcreteHandlerL3 extends AbstractHandler {
   @Override
   protected int getLevel() {
      return 3;
   }

   @Override
   protected String response(RequestObj requestObj) {
      return requestObj.getName()+" 您好！您的流程 L3 节点处理完成";
   }
}

请求处理对象

public class RequestObj {
   private String name;
   private int level;

   public RequestObj(String name, int level) {
      this.name = name;
      this.level = level;
   }

   public String getName() {
      return name;
   }

   public int getLevel() {
      return level;
   }
}

具体处理链客户端

public class HandlerClient implements Handler {
   private AbstractHandler top;

   public HandlerClient() {
      this.top = new ConcreteHandlerL1();
      ConcreteHandlerL2 l2 = new ConcreteHandlerL2();
      ConcreteHandlerL3 l3 = new ConcreteHandlerL3();
      l2.setNextHandler(l3);
      top.setNextHandler(l2);
   }


   @Override
   public String handleMessage(RequestObj requestObj) {
      return top.handleMessage(requestObj);
   }
}

测试驱动类

public class Main {
   public static void main(String[] args) {
      Handler handler = new HandlerClient();
      String response = handler.handleMessage(new RequestObj("tom", 2));
      System.out.println(response);
   }
}

说明：
之所以要在抽象处理类上层有一个处理行为接口，是因为这里加了个额外的具体处理链客户端,从而对外面调用封装链路流程，且只对外暴露处理方法。