责任链模式（Chain of Responsibility Pattern）将链中每一个节点都看作一个对象，每个节点处理的请求均不同，且内部自动维护下一个节点对象。当一个请求从链式的首端发出时，会沿着责任链预设的路径依次传递到每一个节点对象，直至被链中的某个对象处理为止，属于行为型设计模式。
    image.png
    解耦请求与处理，客户端只需要把请求发送到责任链上，请求回自动进行传递，直至有节点对象进行处理。

    1. public abstract class Handler {
    3.     protected Handler nextHandler;
    5.     public Handler getNextHandler() {
    6.         return nextHandler;
    7.     }
    9.     public void setNextHandler(Handler nextHandler) {
    10.         this.nextHandler = nextHandler;
    11.     }
    13.     public abstract void handle(String request);
    15. }
    17. public class ConcreteHandlerA extends Handler {
    19.     @Override
    20.     public void handle(String request) {
    21.         if("A".equals(request)){
    22.             System.out.println("A handler");
    23.             return;
    24.         }
    25.         if(this.nextHandler!= null){
    26.             this.nextHandler.handle(request);
    27.         }
    28.     }
    29. }
    30. public class ConcreteHandlerB extends Handler {
    32.     @Override
    33.     public void handle(String request) {
    34.         if("B".equals(request)){
    35.             System.out.println("B handler");
    36.             return;
    37.         }
    38.         if(this.nextHandler!= null){
    39.             this.nextHandler.handle(request);
    40.         }
    41.     }
    42. }
    43. public class Clinet {
    46.     public static void main(String[] args){
    47.         Handler handlerA = new ConcreteHandlerA();
    48.         Handler handlerB = new ConcreteHandlerB();
    49.         handlerA.setNextHandler(handlerB);
    50.         handlerA.handle("B");
    51.     }
    52. }

    不一定要有一个Handler处理完就只直接返回，也可以每个Handler只处理自己相关的部分，一个Handler处理一部分后交给下一个Hnadler接着处理

    责任链模式与构造者模式混用

    1. public abstract class Handler {
    3.     protected Handler nextHandler;
    5.     private void setNextHandler(Handler nextHandler) {
    6.         this.nextHandler = nextHandler;
    7.     }
    9.     public abstract void handle(String request);
    11.     static class Builder{
    13.         private Handler head;
    15.         private Handler tail;
    17.         public Builder addHandler(Handler handler){
    18.             if(this.head == null){
    19.                 this.head = this.tail = handler;
    20.                 return this;
    21.             }
    22.             this.tail.setNextHandler(handler);
    23.             this.tail = handler;
    24.             return this;
    25.         }
    26.         public Handler build(){
    27.             return this.head;
    28.         }
    29.     }
    30. }
    31.     public static void main(String[] args){
    32.         Handler.Builder builder =  new Handler.Builder();
    33.         builder.addHandler(new ConcreteHandlerA());
    34.         builder.addHandler(new ConcreteHandlerB());
    35.         Handler handler = builder.build();
    36.         handler.handle("B");
    37.     }

    框架

    • Filter
    • Netty的Pipeline

    优点

    • 请求和处理解耦
    • 易于扩展新的处理节点，符合开闭原则
    • 每个处理节点只关注自己的业务/请求
    • 可以动态新增删除责任
    • 处理节点容易复用

    缺点

    • 责任链太长，影响性能
    • 循环引用会造成死循环