责任链模式

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.

责任链模式的通用类图

责任链模式的通用源码

• 抽象处理者

  public abstract class Handler {
      //责任传递，下一个责任人是谁
      private Handler nextHandler;
  
      //每个处理者都必须对请求做出请求
      public final Response handlerMessage(Request request) {
          Response response = null;
          if (this.getHanderLevel().equals(request.getRequestLevel())) {
              response = this.echo(request);
          }
          else {
              if (null != this.nextHandler) {
                  this.nextHandler.handlerMessage(request);
              }
              else {
                  //没有适当的处理者，业务自行处理
              }
          }
          return response;
      }
  
      //设置下一个处理者
      public void setNext(Handler _handler) {
          this.nextHandler = _handler;
      }
  
      //每一个处理者都有一个处理等级
      protected abstract Level getHanderLevel();
      //每一个处理者都必须实现处理请求任务
      protected abstract Response echo(Request request);
  }
  

• 具体处理者类（0）

  public class ConcreteHandler extends Handler {
  
      //定义自己处理的级别
      @Override
      protected Level getHanderLevel() {
          return null;
      }
  
      //顶一一自己处理的逻辑
      @Override
      protected Response echo(Request request) {
          return null;
      }
  }
  

• 具体处理者类（1）

  public class ConcreteHandler1 extends Handler {
  
      //定义自己处理的级别
      @Override
      protected Level getHanderLevel() {
          return null;
      }
  
      //定义自己处理的逻辑
      @Override
      protected Response echo(Request request) {
          return null;
      }
  }
  

• 具体处理者类（2）

  public class ConcreteHandler2 extends Handler {
  
      //定义自己处理的级别
      @Override
      protected Level getHanderLevel() {
          return null;
      }
  
      //定义自己处理的逻辑
      @Override
      protected Response echo(Request request) {
          return null;
      }
  }
  

• 请求类

  public class Request {
      //请求的等级
      public Level getRequestLevel() {
          return null;
      }
  }
  

• 级别类

  public class Level {
      //定义一个请求和处理等级
  }
  

• 回应类

  public class Response {
      //处理者返回的数据
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
          Handler handler = new ConcreteHandler();
          Handler handler1 = new ConcreteHandler1();
          Handler handler2 = new ConcreteHandler2();
  
          //1->2->3
          handler.setNext(handler1);
          handler1.setNext(handler2);
  
          Response response = handler.handlerMessage(new Request());
      }
  }
  

责任链模式的优点

• 将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌。

责任链模式的缺点

• 性能问题。每个请求都是从链头遍历到链尾，特别是在链长的时候，性能一定是非常大的问题。
• 调试不便。链长，由于采用了递归的方式，调试的时候逻辑可能比较复杂。

责任链模式的应用场景

• 用户注册时。

注：使用责任链的时候，要控制链的长度。

责任链模式的简单应用的类图及源码

• 女性接口

  public interface IWomen {
  
      //说明女性个人的情况
      public int getType();
      //说明女性发出的请求
      public String getRequest();
  }
  

• 具体女性类

  public class Women implements IWomen {
  
      /**
       * 说明女性的个人情况
       * 1 -- 女儿
       * 2 -- 妻子
       * 3 -- 母亲
       */
      private int type;
      //说明女性个人发出的请求
      private String request;
  
      public Women(int _type, String _request) {
          this.type = _type;
          switch (this.type) {
          case 1:
              this.request = "女儿向父亲请求是" + _request;
              break;
          case 2:
              this.request = "妻子向丈夫请求是" + _request;
              break;
          case 3:
              this.request = "母亲向儿子请求是" + _request;
              break;
          }
      }
  
      @Override
      public int getType() {
          return this.type;
      }
  
      @Override
      public String getRequest() {
          return this.request;
      }
  }
  

• 抽象处理类

  public abstract class IHandler {
  
      public final static int FATHER_LEVEL_REQUEST = 1;
      public final static int HUSBAND_LEVEL_REQUEST = 2;
      public final static int SON_LEVEL_REQUEST = 3;
      //能处理的级别
      private int level = 0;
      //责任传递，下一个责任人是谁
      private IHandler nextHandler;
      //每一类都要说明自己能处理的哪些请求
      public IHandler(int _level) {
          this.level = _level;
      }
  
      //一个女性要求逛街，你需要处理这个请求
      public final void handlerMessage(IWomen women) {
          if (women.getType() == this.level) {
              this.response(women);
          }
          else {
              if (null != this.nextHandler) {
                  this.nextHandler.handlerMessage(women);
              }
              else {
                  System.out.println("--   不同意");
              }
          }
      }
  
      // 如果不是你的处理请求，你应该让他找下一个环节的人
      public void setNext(IHandler _handler) {
          this.nextHandler = _handler;
      }
  
      // 有请求自然要回应
      protected abstract void response(IWomen women);
  }
  

• 具体处理类（父亲）

  public class Father extends IHandler {
  
      public Father() {
          super(IHandler.FATHER_LEVEL_REQUEST);
      }
  
      @Override
      protected void response(IWomen women) {
          System.out.println("女儿向父亲发出请求");
          System.out.println(women.getRequest());
          System.out.println("父亲 -----------> 同意");
      }
  }
  

• 具体处理类（丈夫）

  public class Husband extends IHandler {
  
      public Husband() {
          super(HUSBAND_LEVEL_REQUEST);
      }
  
      @Override
      protected void response(IWomen women) {
          System.out.println("妻子向丈夫发出请求");
          System.out.println(women.getRequest());
          System.out.println("丈夫 -----------> 同意");
      }
  }
  

• 具体处理类（儿子）

  public class Son extends IHandler {
  
      public Son() {
          super(SON_LEVEL_REQUEST);
      }
  
      @Override
      protected void response(IWomen women) {
          System.out.println("母亲向儿子发出请求");
          System.out.println(women.getRequest());
          System.out.println("儿子 -----------> 同意");
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          Random random = new Random();
          ArrayList<IWomen> list = new ArrayList<IWomen>();
          for (int i = 0; i < 5; i++) {
              list.add(new Women(random.nextInt(3) + 1, "我要逛街"));
          }
  
          IHandler father = new Father();
          IHandler husband = new Husband();
          IHandler son = new Son();
  
          father.setNext(husband);
          husband.setNext(son);
  
          for(IWomen women : list) {
              father.handlerMessage(women);
          }
      }
  
  }