概述

责任链模式在面试中经常被问到，虽然知道哪些地方用到责任链模式（事件分发机制/OKHttp拦截器等），责任链模式的核心在于‘链’。将多个对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。有点像switch语句/if else语句，最终有个条件兜底处理该语句。

使用场景

  • 多个对象可以处理同一个请求，具体由哪个对象处理是在运行时决定的。

    UML

    责任链模式-基础 - 图1抽象处理者

    1. /**
    2. * 抽象处理者角色：声明一个请求处理的方法，
    3. * 并在其中保持一个对下一个处理节点Handler对象引用。
    4. **/
    5. public abstract class Handler {
    6.   // 下一个节点处理者
    7.   protected Handler successor;
    9.   // 请求处理
    10.   public abstract void handleRequest(String condition);
    11. }

    具体处理者1

    1. /**
    2. * 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。
    3. */
    4. public class ConcreteHandler1 extends Handler {
    5.   @Override
    6.   public void handleRequest(String condition) {
    7.       if (condition.equals("ConcreteHandler1")) {
    8.           System.out.println("ConcreteHandler1 handled !!!! ");
    9.           return;
    10.       } else {
    11.           successor.handleRequest(condition);// 处理下一个节点
    12.       }
    13.   }
    14. }

    具体处理者2

    1. /**
    2. * 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。
    3. */
    4. public class ConcreteHandler2 extends Handler {
    5.   @Override
    6.   public void handleRequest(String condition) {
    7.       if (condition.equals("ConcreteHandler2")) {
    8.           System.out.println("ConcreteHandler2 handled !!!! ");
    9.           return;
    10.       } else {
    11.           successor.handleRequest(condition);// 处理下一个节点
    12.       }
    13.   }
    14. }

    客户调用

    1. public class Client {
    2.   public static void main(String[] args) {
    3.       ConcreteHandler1 handler1 = new ConcreteHandler1();
    4.       ConcreteHandler2 handler2 = new ConcreteHandler2();
    6.       // 设置下一个节点
    7.       handler1.successor = handler2;
    8.       handler2.successor = handler1;
    10.       handler1.handleRequest("ConcreteHandler1");
    11.   }
    12. }

责任链模式-基础 - 图2抽象处理者

  1. public abstract class AbstractHandler {
  2.     protected AbstractHandler nextHandler;// 下一节点处理对象
  4.     // 请求对象
  5.     public final void handleRequest(AbstractRequest request) {
  6.         if (getHandlerLevel() == request.getRequestLevel()) {
  7.             handle(request);
  8.         } else {
  9.             if (nextHandler != null) {
  10.                 nextHandler.handleRequest(request);
  11.             } else {
  12.                 System.out.println("");
  13.             }
  14.         }
  15.     }
  17.     // 获取处理者对象的处理级别
  18.     protected abstract int getHandlerLevel();
  20.     // 每个处理者对象的具体处理方式
  21.     protected abstract void handle(AbstractRequest request);
  22. }

抽象请求者

  1. public abstract class AbstractRequest {
  2.     protected Object obj;// 处理对象
  4.     public AbstractRequest(Object obj) {
  5.         this.obj = obj;
  6.     }
  8.     // 获取处理的内容对象
  9.     public Object getContent() {
  10.         return obj;
  11.     }
  13.     // 获取请求级别
  14.     public abstract int getRequestLevel();
  15. }

处理者

  1. public class Handler1 extends AbstractHandler {
  2.     @Override
  3.     protected int getHandlerLevel() {
  4.         return 1;
  5.     }
  7.     @Override
  8.     protected void handle(AbstractRequest request) {
  9.         System.out.println("Handler1 handle request: " + request.getRequestLevel());
  10.     }
  11. }
  13. public class Handler2 extends AbstractHandler {
  14.     @Override
  15.     protected int getHandlerLevel() {
  16.         return 2;
  17.     }
  19.     @Override
  20.     protected void handle(AbstractRequest request) {
  21.         System.out.println("Handler2 handle request: " + request.getRequestLevel());
  22.     }
  23. }
  25. public class Handler3 extends AbstractHandler {
  26.     @Override
  27.     protected int getHandlerLevel() {
  28.         return 2;
  29.     }
  31.     @Override
  32.     protected void handle(AbstractRequest request) {
  33.         System.out.println("Handler3 handle request: " + request.getRequestLevel());
  34.     }
  35. }

请求者

  1. public class Request1 extends AbstractRequest{
  3.     public Request1(Object obj) {
  4.         super(obj);
  5.     }
  7.     @Override
  8.     public int getRequestLevel() {
  9.         return 1;
  10.     }
  11. }
  13. public class Request2 extends AbstractRequest{
  15.     public Request2(Object obj) {
  16.         super(obj);
  17.     }
  19.     @Override
  20.     public int getRequestLevel() {
  21.         return 2;
  22.     }
  23. }
  25. public class Request3 extends AbstractRequest{
  27.     public Request3(Object obj) {
  28.         super(obj);
  29.     }
  31.     @Override
  32.     public int getRequestLevel() {
  33.         return 3;
  34.     }
  35. }

客户调用

  1. public class Client {
  2.     public static void main(String[] args) {
  3.         // 构造3个处理者对象
  4.         AbstractHandler handler1 = new Handler1();
  5.         AbstractHandler handler2 = new Handler2();
  6.         AbstractHandler handler3 = new Handler3();
  8.         // 设置当前处理者对象下一个节点的处理者对象
  9.         handler1.nextHandler = handler2;
  10.         handler2.nextHandler = handler3;
  12.         // 构造3个请求对象
  13.         AbstractRequest request1 = new Request1("Request1");
  14.         AbstractRequest request2 = new Request2("Request2");
  15.         AbstractRequest request3 = new Request3("Request3");
  17.         // 从链式首端发起请求
  18.         handler1.handle(request1);
  19.         handler1.handle(request2);
  20.         handler1.handle(request3);
  21.     }
  22. }

Coding

  1. public abstract class Leader {
  2.     protected Leader nextHandler;
  4.     public final void handleRequest(int money) {
  5.         if (money <= limit()) {
  6.             handle(money);
  7.         } else {
  8.             if (null != nextHandler) {
  9.                 nextHandler.handleRequest(money);
  10.             }
  11.         }
  12.     }
  14.     public abstract int limit();
  16.     public abstract void handle(int money);
  17. }
  19. public class Grouper extends Leader {
  20.     @Override
  21.     public int limit() {
  22.         return 1000;
  23.     }
  25.     @Override
  26.     public void handle(int money) {
  27.         System.out.println("组长批复报销： " + money + "元");
  28.     }
  29. }
  31. public class Director extends Leader {
  32.     @Override
  33.     public int limit() {
  34.         return 5000;
  35.     }
  37.     @Override
  38.     public void handle(int money) {
  39.         System.out.println("主管批复报销：" + money + "元");
  40.     }
  41. }
  43. public class Manager extends Leader {
  44.     @Override
  45.     public int limit() {
  46.         return 10000;
  47.     }
  49.     @Override
  50.     public void handle(int money) {
  51.         System.out.println("经理批复报销：" + money + "元");
  52.     }
  53. }
  55. public class Boss extends Leader {
  56.     @Override
  57.     public int limit() {
  58.         return Integer.MAX_VALUE;
  59.     }
  61.     @Override
  62.     public void handle(int money) {
  63.         System.out.println("老板批复报销：" + money + "元");
  64.     }
  65. }
  1. public class Client {
  2.     public static void main(String[] args) {
  3.         Grouper grouper = new Grouper();
  4.         Director director = new Director();
  5.         Manager manager = new Manager();
  6.         Boss boss = new Boss();
  7.         grouper.nextHandler = director;
  8.         director.nextHandler = manager;
  9.         manager.nextHandler = boss;
  10.         grouper.handleRequest(5000);
  11.     }
  12. }