设计模式之责任链模式

一、简介

将不同职责的步骤串联起来执行，并且一个步骤执行完成之后才能够执行下一个步骤。

在这种模式中，通常每个接收者都包含对另一个接收者的引用，责任链模式虽然常见于链表结构，但是也可以使用数组来实现

二、实现方式

• 抽象处理器（Handler） 处理器的接口或抽象类，定义了处理请求的方法并持有下一个处理器对象的引用

  public abstract class Handler {
      private Handler nextHandler;
      public Handler getNextHandler() {
          return nextHandler;
      }
      public void setNextHandler(Handler nextHandler) {
          this.nextHandler = nextHandler;
      }
      public abstract void handle(Object request);
  }
  

• 具体处理器（ConcreteHandler） 实现了Handler，先根据请求执行处理逻辑，执行完后将请求交给下一个处理器执行

  ## 具体处理器1、2、3
  public class ConcreteHandler1 extends Handler {
      @Override
      public void handle(Object request) {
          System.out.println("concrete handler 1 execute request. request: " + request);
          if (getNextHandler() != null) {
              getNextHandler().handle(request);
          }
      }
  }
  

• 调用者 负责创建处理器并将请求交给处理器进行处理

  public class ChainTest {
      public static void main(String[] args) {
          Handler concreteHandler1 = new ConcreteHandler1();
          Handler concreteHandler2 = new ConcreteHandler2();
          Handler concreteHandler3 = new ConcreteHandler3();
  
          concreteHandler1.setNextHandler(concreteHandler2);
          concreteHandler2.setNextHandler(concreteHandler3);
  
          concreteHandler1.handle("my request.");
      }
  }
  

三、应用场景

1、Springcloud gateway中的适配器模式和责任链模式-globalfilter、gatewayfilter和defaultgatewayfilterchain

2、SpringMVC中的责任链模式：处理器执行链HandlerExecutionChain

在处理器拦截器HandlerInterceptor接口中，定义了三个方法，分别是前置处理(preHandle)、后置处理(postHandle)和整个流程完成之后的处理(afterCompletion)

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

通过处理器执行链 HandlerExecutionChain 将拦截器串联起来，所有的拦截器都存放在 interceptors 数组中，通过遍历 interceptors 数组依次执行相应的方法

public class HandlerExecutionChain {
    @Nullable
    private HandlerInterceptor[] interceptors;

    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {
                HandlerInterceptor interceptor = interceptors[i];
                if (!interceptor.preHandle(request, response, this.handler)) {
                    this.triggerAfterCompletion(request, response, (Exception)null);
                    return false;
                }
            }
        }

        return true;
    }

    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = interceptors.length - 1; i >= 0; --i) {
                HandlerInterceptor interceptor = interceptors[i];
                interceptor.postHandle(request, response, this.handler, mv);
            }
        }

    }

    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = this.interceptorIndex; i >= 0; --i) {
                HandlerInterceptor interceptor = interceptors[i];

                try {
                    interceptor.afterCompletion(request, response, this.handler, ex);
                } catch (Throwable var8) {
                    logger.error("HandlerInterceptor.afterCompletion threw exception", var8);
                }
            }
        }

    }
}

四、思维导图