原文：https://github.com/CyC2018/CS-Notes

责任链（Chain Of Responsibility）

职责链模式：避免将请求发送者与接收者耦合在一起，让多个对象都有机会接收请求，将这些对象连接成一条链，并且沿着这条链传递请求。职责链模式是一种对象行为型模式。分为纯责任链模式和不纯责任链模式，纯责任链模式：请求被具体处理器处理，不存在不被处理的请求。不纯责任链：请求被具体处理器处理后，继续往后传递，而且可以最终不被任何处理者对象接收。

Intent

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。

Class Diagram

  • Handler：定义处理请求的接口，并且实现后继链（successor）

责任链设计模式 - 图1

Implementation

  1. public abstract class Handler {
  3.     protected Handler successor;
  4.     public Handler(Handler successor) {
  5.         this.successor = successor;
  6.     }
  8.     protected abstract void handleRequest(Request request);
  9. }
  1. public class ConcreteHandler1 extends Handler {
  3.     public ConcreteHandler1(Handler successor) {
  4.         super(successor);
  5.     }
  8.     @Override
  9.     protected void handleRequest(Request request) {
  10.         if (request.getType() == RequestType.TYPE1) {
  11.             System.out.println(request.getName() + " is handle by ConcreteHandler1");
  12.             return;
  13.         }
  14.         if (successor != null) {
  15.             successor.handleRequest(request);
  16.         }
  17.     }
  18. }
  1. public class ConcreteHandler2 extends Handler {
  3.     public ConcreteHandler2(Handler successor) {
  4.         super(successor);
  5.     }
  7.     @Override
  8.     protected void handleRequest(Request request) {
  9.         if (request.getType() == RequestType.TYPE2) {
  10.             System.out.println(request.getName() + " is handle by ConcreteHandler2");
  11.             return;
  12.         }
  13.         if (successor != null) {
  14.             successor.handleRequest(request);
  15.         }
  16.     }
  17. }
  1. public class Request {
  3.     private RequestType type;
  4.     private String name;
  7.     public Request(RequestType type, String name) {
  8.         this.type = type;
  9.         this.name = name;
  10.     }
  13.     public RequestType getType() {
  14.         return type;
  15.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  21. }
  1. public enum RequestType {
  2.     TYPE1, TYPE2
  3. }
  1. public class Client {
  3.     public static void main(String[] args) {
  5.         Handler handler1 = new ConcreteHandler1(null);
  6.         Handler handler2 = new ConcreteHandler2(handler1);
  8.         Request request1 = new Request(RequestType.TYPE1, "request1");
  9.         handler2.handleRequest(request1);
  11.         Request request2 = new Request(RequestType.TYPE2, "request2");
  12.         handler2.handleRequest(request2);
  13.     }
  14. }
  1. request1 is handle by ConcreteHandler1
  2. request2 is handle by ConcreteHandler2

JDK

使用场景

  1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及他是如何处理的。
  2. 在不明确接收者的情况下，向多个对象中的一个提交一个请求。
  3. 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序。