Spring中用到的几种典型的设计模式

末蓝、 2023-02-14 10:42 99阅读 0赞

Spring 框架中用到的设计模式非常多，不下十几种。本文只挑选几种典型的来解析。

适配器模式应用在Spring MVC中

Spring MVC定义一个Controller最常用的方式是，通过@Controller注解来标记某个类是Controller类，通过@RequesMapping注解来标记函数对应的URL。不过，定义一个Controller远不止这一种方法。我们还可以通过让类实现Controller接口或者Servlet接口，来定义一个 Controller。这三种定义方式示例代码，如下所示：

  1. //方法一：通过@Controller、@RequestMapping来定义
  2. @Controller
  3. public class DemoController { 
  5.     @RequestMapping("/getUserName")
  6.     public ModelAndView getUserName() { 
  7.         ModelAndView model = new ModelAndView("Greeting");
  8.         model.addObject("message", "TOM");
  9.         return model;
  10.     }
  11. }
  12. //方法二：实现Controller接口 + xml配置文件:配置DemoController与URL的对应关系
  13. public class DemoControllerImpl implements Controller { 
  14.     @Override
  15.     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception { 
  16.         ModelAndView model = new ModelAndView("HelloWorld");
  17.         model.addObject("message", "HelloWorld");
  18.         return model;
  19.     }
  20. }
  21. //方法三：继承HttpServlet抽象类 + xml配置文件:配置DemoExtendServletController类与URL的对应关系
  22. public class DemoExtendServletController extends HttpServlet { 
  24.     @Override
  25.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
  26.         this.doPost(req, resp);
  27.     }
  29.     @Override
  30.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
  31.         resp.getWriter().write("Hello World!");
  32.     }
  33. }

在应用启动的时候，Spring容器会加载这些Controller类，并且解析出URL对应的处理函数，封装成Handler对象，存储到HandlerMapping对象中。当有请求到来的时候，DispatcherServlet从HanderMapping中，查找请求URL对应的Handler，然后调用执行Handler对应的函数代码，最后将执行结果返回给客户端。

但是不同方式定义的Controller，其函数的定义（函数名、入参、返回值等）是不统一的。方法一中的函数的定义很随意、不固定，方法二中的函数定义是 handleRequest()、方法三中的函数定义是HttpServlet的service()方法(实际上这里用到了模板方法模式，Servlet中的service()调用了doGet()或doPost()方法，DispatcherServlet调用的是service()方法)。

DispatcherServlet需要根据不同类型的Controller，调用不同的函数，下面是伪代码：

  1. Handler handler = handlerMapping.get(URL);
  2. if (handler instanceof Controller) { 
  3.   ((Controller)handler).handleRequest();
  4. } else if (handler instanceof Servlet) { 
  5.   ((Servlet)handler).service(...);
  6. } else if (handler.getClass().getAnnotation(Controller.class) != null) {  
  7.   //反射调用RequestMapping修饰的方法...
  8. }

这种实现方式会有很多if-else分支判断，而且，如果要增加一个新的 Controller的定义方法，我们就要在DispatcherServlet类代码中，对应地增加一段如上伪代码所示的if逻辑，这显然不符合开闭原则。

可以利用是适配器模式对代码进行改造，让其满足开闭原则，能更好地支持扩展，适配器其中一个作用是“统一多个类的接口设计”。利用适配器模式，我们将不同方式定义的Controller类中的函数适配为统一的函数定义。这样，我们就能在DispatcherServlet类代码中，移除掉if-else分支判断逻辑，调用统一的函数。

来具体看下Spring的代码实现。Spring定义了统一的接口HandlerAdapter，并且对每种Controller定义了对应的适配器类。这些适配器类包括：AnnotationMethodHandlerAdapter、SimpleControllerHandlerAdapter、SimpleServletHandlerAdapter等，源码如下。

  1. //统一的controller处理器适配接口
  2. public interface HandlerAdapter { 
  3.   boolean supports(Object var1);
  4.   ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;
  5.   long getLastModified(HttpServletRequest var1, Object var2);
  6. }
  7. // 对应实现Controller接口的Controller
  8. public class SimpleControllerHandlerAdapter implements HandlerAdapter { 
  9.   public SimpleControllerHandlerAdapter() { 
  10.   }
  12.   @Override
  13.   public boolean supports(Object handler) { 
  14.     return handler instanceof Controller;
  15.   }
  17.   @Override
  18.   public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
  19.     return ((Controller)handler).handleRequest(request, response);
  20.   }
  22.   @Override
  23.   public long getLastModified(HttpServletRequest request, Object handler) { 
  24.     return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
  25.   }
  26. }
  27. // 对应实现Servlet接口的Controller
  28. public class SimpleServletHandlerAdapter implements HandlerAdapter { 
  29.   public SimpleServletHandlerAdapter() { 
  30.   }
  32.   @Override
  33.   public boolean supports(Object handler) { 
  34.     return handler instanceof Servlet;
  35.   }
  37.   @Override
  38.   public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
  39.     ((Servlet)handler).service(request, response);
  40.     return null;
  41.   }
  42.   //省略...
  43. }
  44. //AnnotationMethodHandlerAdapter对应通过注解实现的Controller，
  45. public class AnnotationMethodHandlerAdapter extends WebContentGenerator
  46.     implements HandlerAdapter, Ordered, BeanFactoryAware { 
  48.   @Override
  49.   public boolean supports(Object handler) { 
  50.     return getMethodResolver(handler).hasHandlerMethods();
  51.   }
  53.   @Override
  54.   public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
  55.       throws Exception { 
  56.     Class<?> clazz = ClassUtils.getUserClass(handler);
  57.     Boolean annotatedWithSessionAttributes = this.sessionAnnotatedClassesCache.get(clazz);
  58.     if (annotatedWithSessionAttributes == null) { 
  59.       annotatedWithSessionAttributes = (AnnotationUtils.findAnnotation(clazz, SessionAttributes.class) != null);
  60.       this.sessionAnnotatedClassesCache.put(clazz, annotatedWithSessionAttributes);
  61.     }
  62.     if (annotatedWithSessionAttributes) { 
  63.       checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);
  64.     } else { 
  65.       checkAndPrepare(request, response, true);
  66.     }
  67.     //...省略
  68.     return invokeHandlerMethod(request, response, handler);
  69.   }
  70.     //...省略
  71. }

在DispatcherServlet类中，我们就不需要区分对待不同的Controller对象了，统一调用HandlerAdapter的handle()函数就可以了，这样就没有烦人的if-else逻辑了。以下摘抄Spring-web-mvc-5.1.14.RELEASE-sources.jar中的DispatcherServlet类中与HandlerAdapter相关的部分核心代码，可以看到在容器启动后，通过调用initHandlerAdapters()函数获取context中的类型为HandlerAdapter的bean列表，在doDispatch()函数中会根据当前handler的类型，挑选出合适的适配器。

  1. public class DispatcherServlet extends FrameworkServlet { 
  3.     /** List of HandlerAdapters used by this servlet. */
  4.     @Nullable
  5.     private List<HandlerAdapter> handlerAdapters;
  7.     /** Detect all HandlerAdapters or just expect "handlerAdapter" bean?. */
  8.     private boolean detectAllHandlerAdapters = true;
  9.     //省略大部分属性....
  11.     protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { 
  12.         HttpServletRequest processedRequest = request;
  13.         HandlerExecutionChain mappedHandler = null;
  14.         boolean multipartRequestParsed = false;
  15.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  16.         try { 
  17.             ModelAndView mv = null;
  18.             Exception dispatchException = null;
  19.             try { 
  20.                 processedRequest = checkMultipart(request);
  21.                 multipartRequestParsed = (processedRequest != request);
  22.                 // Determine handler for the current request.
  23.                 mappedHandler = getHandler(processedRequest);
  24.                 if (mappedHandler == null) { 
  25.                     noHandlerFound(processedRequest, response);
  26.                     return;
  27.                 }
  28.                 // Determine handler adapter for the current request.
  29.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  31.                 //中间部分省略...
  33.                 // Actually invoke the handler.
  34.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  35.                 //各种catch异常的逻辑省略...
  36.         }
  37.     }
  39.     //获取适配器，找到第一个匹配的就返回
  40.     protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException { 
  41.         if (this.handlerAdapters != null) { 
  42.             for (HandlerAdapter adapter : this.handlerAdapters) { 
  43.                 if (adapter.supports(handler)) { 
  44.                     return adapter;
  45.                 }
  46.             }
  47.         }
  48.         throw new ServletException("No adapter for handler [" + handler +
  49.                 "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
  50.     }
  52.     @Override
  53.     protected void onRefresh(ApplicationContext context) { 
  54.         initStrategies(context);
  55.     }
  57.     protected void initStrategies(ApplicationContext context) { 
  58.         //省略...
  59.         initHandlerAdapters(context);
  60.         //省略...
  61.     }
  63.     //初始化适配器列表
  64.     private void initHandlerAdapters(ApplicationContext context) { 
  65.         this.handlerAdapters = null;
  67.         if (this.detectAllHandlerAdapters) { 
  68.             // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
  69.             Map<String, HandlerAdapter> matchingBeans =
  70.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
  71.             if (!matchingBeans.isEmpty()) { 
  72.                 this.handlerAdapters = new ArrayList<>(matchingBeans.values());
  73.                 // We keep HandlerAdapters in sorted order.
  74.                 AnnotationAwareOrderComparator.sort(this.handlerAdapters);
  75.             }
  76.         }
  77.         //以下省略...
  78.     }
  79. }

策略模式的应用

Spring中的AOP是通过动态代理来实现的。具体到代码实现，Spring支持两种动态代理实现方式，一种是JDK提供的动态代理实现方式，另一种是Cglib提供的动态代理实现方式。前者需要被代理的类有抽象的接口定义，后者不需要。针对不同的被代理类，Spring会在运行时动态地选择不同的动态代理实现方式。

动态选择代理策略，这里就用到了策略模式。策略模式包含三部分，策略的定义、创建和使用。具体到Spring中的策略模式，策略的定义这一部分很简单，我们只需要定义一个策略接口，让不同的策略类都实现这一个策略接口。对应到Spring的源码AopProxy是策略接口，JdkDynamicAopProxy、CglibAopProxy是两个实现了AopProxy接口的策略类。其中，AopProxy接口的定义如下所示：

  1. public interface AopProxy { 
  2.     Object getProxy();
  3.     Object getProxy(ClassLoader var1);
  4. }

策略的创建一般通过工厂方法来实现。对应到Spring源码，AopProxyFactory是一个工厂类接口，DefaultAopProxyFactory是一个默认的工厂类，用来创建AopProxy对象。两者的源码如下所示：

  1. public interface AopProxyFactory { 
  2.     AopProxy createAopProxy(AdvisedSupport var1) throws AopConfigException;
  3. }
  6. public class DefaultAopProxyFactory implements AopProxyFactory, Serializable { 
  8.   @Override
  9.   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { 
  10.       //optimized默认是false || proxy-target-class=true || 没有接口
  11.     if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) { 
  12.       Class<?> targetClass = config.getTargetClass();
  13.       if (targetClass == null) { 
  14.         throw new AopConfigException("TargetSource cannot determine target class: " +
  15.             "Either an interface or a target is required for proxy creation.");
  16.       }
  17.       //被代理类是接口，创建JDK代理
  18.       if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { 
  19.         return new JdkDynamicAopProxy(config);
  20.       }
  21.       return new ObjenesisCglibAopProxy(config);
  22.     }
  23.     else { 
  24.       return new JdkDynamicAopProxy(config);
  25.     }
  26.   }
  28.   /** * Determine whether the supplied {@link AdvisedSupport} has only the * {@link org.springframework.aop.SpringProxy} interface specified * (or no proxy interfaces specified at all). */
  29.   private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) { 
  30.     Class<?>[] ifcs = config.getProxiedInterfaces();
  31.     return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
  32.   }
  34. }

策略模式的典型应用场景，一般是通过环境变量、状态值、计算结果等动态地决定使用哪个策略。对应到Spring源码中，我们可以参看刚刚给出的DefaultAopProxyFactory类中的createAopProxy()函数的代码实现。其中包含了多处if-else分支，用来判断要用哪种策略生成代理类。

Spring对观察者模式的实现

Java及Google Guava都提供了观察者模式的实现框架。Java 提供的框架比较简单，只包含java.util.Observable和java.util.Observer两个类。Google Guava提供的框架功能比较完善和强大：通过EventBus事件总线来实现观察者模式，可以参见之前的博文观察者模式及EventBus框架简单实现去了解Guava是怎样实现观察者模式的。

实际上，Spring中的事件驱动模型也叫作发布订阅模式，是观察者模式的一个典型的应用。Spring中实现的观察者模式包含三部分：Event事件（相当于消息）、Listener 监听者（相当于观察者）、Publisher发送者（相当于被观察者）。我们通过一个例子来看下，Spring提供的观察者模式使用代码如下所示：

  1. // Event事件
  2. public class DemoEvent extends ApplicationEvent { 
  3.   private String message;
  5.   public DemoEvent(Object source, String message) { 
  6.     super(source);
  7.   }
  9.   public String getMessage() { 
  10.     return this.message;
  11.   }
  12. }
  14. // Listener监听者
  15. @Component
  16. public class DemoListener implements ApplicationListener<DemoEvent> { 
  17.   @Override
  18.   public void onApplicationEvent(DemoEvent demoEvent) { 
  19.     String message = demoEvent.getMessage();
  20.     System.out.println(message);
  21.   }
  22. }
  24. // Publisher发送者
  25. @Component
  26. public class DemoPublisher { 
  27.   public void publishEvent(DemoEvent demoEvent) { 
  28.     SpringContext.getApplicationContext.publishEvent(demoEvent);
  29.   }
  30. }
  33. // 创建一个Spring上下文bean，拿到ApplicationContext
  34. @Component
  35. public class SpringContext implements ApplicationContextAware { 
  36.     private static ApplicationContext applicationContext;
  38.     @Override
  39.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
  40.         SpringContext.applicationContext = applicationContext;
  41.     }
  43.     public static ApplicationContext getApplicationContext() { 
  44.         return applicationContext;
  45.     }
  46. }

框架使用起来并不复杂，主要包含三部分工作：定义一个继承 ApplicationEvent的事件（DemoEvent）；定义一个实现了 ApplicationListener的监听器（DemoListener）；定义一个发送者（DemoPublisher），发送者调用ApplicationContext来发送事件消息。其中，ApplicationEvent和ApplicationListener的代码实现都非常简单，内部并不包含太多属性和方法。实际上，它们最大的作用是做类型标识之用：继承自ApplicationEvent的类是事件，实现了ApplicationListener的类是监听器。

在观察者模式中，观察者是需要事先注册到被观察者中的。那在Spring的实现中，观察者注册到了哪里呢？又是如何注册的呢？Spring把观察者注册到了ApplicationContext对象中。这里的ApplicationContext就相当于Google EventBus框架中的“事件总线”。不过ApplicationContext这个类并不只是为观察者模式服务的。它底层依赖BeanFactory（IOC 的主要实现类），提供应用启动、运行时的上下文信息。具体到源码来说，ApplicationContext只是一个接口，具体的代码实现包含在它的实现类AbstractApplicationContext中，该类中事件相关的代码摘抄如下：

  1. public abstract class AbstractApplicationContext extends DefaultResourceLoader
  2.     implements ConfigurableApplicationContext, DisposableBean { 
  4.   //....省略
  6.   /** Helper class used in event publishing */
  7.   private ApplicationEventMulticaster applicationEventMulticaster;
  9.   /** Statically specified listeners */
  10.   private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<ApplicationListener<?>>();
  12.   @Override
  13.   public void publishEvent(ApplicationEvent event) { 
  14.     publishEvent(event, null);
  15.   }
  17.   @Override
  18.   public void publishEvent(Object event) { 
  19.     publishEvent(event, null);
  20.   }
  22.   protected void publishEvent(Object event, ResolvableType eventType) { 
  23.     Assert.notNull(event, "Event must not be null");
  24.     if (logger.isTraceEnabled()) { 
  25.       logger.trace("Publishing event in " + getDisplayName() + ": " + event);
  26.     }
  27.     // Decorate event as an ApplicationEvent if necessary
  28.     ApplicationEvent applicationEvent;
  29.     if (event instanceof ApplicationEvent) { 
  30.       applicationEvent = (ApplicationEvent) event;
  31.     } else { 
  32.       applicationEvent = new PayloadApplicationEvent<Object>(this, event);
  33.       if (eventType == null) { 
  34.         eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
  35.       }
  36.     }
  38.     // Multicast right now if possible - or lazily once the multicaster is initialized
  39.     if (this.earlyApplicationEvents != null) { 
  40.       this.earlyApplicationEvents.add(applicationEvent);
  41.     } else { 
  42.       getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
  43.     }
  45.     // Publish event via parent context as well...
  46.     if (this.parent != null) { 
  47.       if (this.parent instanceof AbstractApplicationContext) { 
  48.         ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
  49.       } else { 
  50.         this.parent.publishEvent(event);
  51.       }
  52.     }
  53.   }
  55.   @Override
  56.   public void addApplicationListener(ApplicationListener<?> listener) { 
  57.     Assert.notNull(listener, "ApplicationListener must not be null");
  58.     if (this.applicationEventMulticaster != null) { 
  59.       this.applicationEventMulticaster.addApplicationListener(listener);
  60.     } else { 
  61.       this.applicationListeners.add(listener);
  62.     }
  63.   }
  65.   // ApplicationEventMulticaster初始化
  66.   protected void initApplicationEventMulticaster() { 
  67.     ConfigurableListableBeanFactory beanFactory = getBeanFactory();
  68.     if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { 
  69.       this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
  70.       if (logger.isDebugEnabled()) { 
  71.         logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
  72.       }
  73.     } else { 
  74.       this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
  75.       beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
  76.       if (logger.isDebugEnabled()) { 
  77.         logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
  78.             APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
  79.             "': using default [" + this.applicationEventMulticaster + "]");
  80.       }
  81.     }
  82.   }
  84.   protected void registerListeners() { 
  85.     // Register statically specified listeners first.
  86.     for (ApplicationListener<?> listener : getApplicationListeners()) { 
  87.       getApplicationEventMulticaster().addApplicationListener(listener);
  88.     }
  90.     // Do not initialize FactoryBeans here: We need to leave all regular beans
  91.     // uninitialized to let post-processors apply to them!
  92.     String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
  93.     for (String listenerBeanName : listenerBeanNames) { 
  94.     getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
  95.     }
  97.     // Publish early application events now that we finally have a multicaster...
  98.     Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
  99.     this.earlyApplicationEvents = null;
  100.     if (earlyEventsToProcess != null) { 
  101.       for (ApplicationEvent earlyEvent : earlyEventsToProcess) { 
  102.         getApplicationEventMulticaster().multicastEvent(earlyEvent);
  103.       }
  104.     }
  105.   }
  107.   //....省略
  109. }

从上面的代码中，我们发现，真正的消息发送以及观察者注册实际上是通过 ApplicationEventMulticaster这个类来完成的。这个类的源码我只摘抄最关键的一部分，也就是multicastEvent()这个消息发送函数。部分关键代码如下，它通过线程池，支持异步非阻塞、同步阻塞这两种类型的观察者模式。

  1. public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster { 
  3.   private Executor taskExecutor;
  5.   public SimpleApplicationEventMulticaster() { 
  6.   }
  8.   public void setTaskExecutor(Executor taskExecutor) { 
  9.     this.taskExecutor = taskExecutor;
  10.   }
  12.   protected Executor getTaskExecutor() { 
  13.     return this.taskExecutor;
  14.   }
  16.   @Override
  17.   public void multicastEvent(ApplicationEvent event) { 
  18.     multicastEvent(event, resolveDefaultEventType(event));
  19.   }
  21.   @Override
  22.   public void multicastEvent(final ApplicationEvent event, ResolvableType eventType) { 
  23.     ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
  24.     for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) { 
  25.       Executor executor = getTaskExecutor();
  26.       if (executor != null) { 
  27.         executor.execute(new Runnable() { 
  28.           @Override
  29.           public void run() { 
  30.             invokeListener(listener, event);
  31.           }
  32.         });
  33.       } else { 
  34.         invokeListener(listener, event);
  35.       }
  36.     }
  37.   }
  38. }

借助Spring提供的观察者模式的骨架代码，如果我们要在Spring下实现某个事件的发送和监听，只需要做很少的工作：定义事件、定义监听器、往ApplicationContext中发送事件就可以了。剩下的工作都由Spring框架来完成。这体现了Spring框架的扩展性，也就是在不需要修改任何代码的情况下，扩展新的事件和监听。在Spring boot中可支持直接使用@EnableAsync、@EventListener等注解定义异步或同步监听器。

模板方法模式的应用

Java IO类库中的很多类都用到了模板方法模式，许多xxxxTemplate类都用到了回调模式，详情见模板方法模式与回调函数这篇博客。

职责链模式实现Spring Interceptor

职责链模式：将能够处理同一类请求的对象连成一条链，使这些对象都有机会处理请求，所提交的请求沿着链传递。从而避免请求的发送者和接受者之间的耦合关系。链上的对象逐个判断是否有能力处理该请求，如果能则就处理，如果不能，则传给链上的下一个对象，直到有一个对象处理它为止。

用一张生动一些的图来描述一下，就是下面这样。在公司中不同的岗位拥有不同的职责与权限。以上述的请假流程为例，当员工请 1天假时，只要组长审批就可以了，不需要流转到主管和总监。如果职责链上的某个环节无法处理当前的请求，在含有下个环节时，则会把请求转交给下个环节来处理。
20210225151454397.png

职责链的UML图如下：
20200606204433117.png

职责链模式的典型示例代码如下：

  1. public interface IHandler { 
  2.   boolean handle();
  3. }
  5. public class HandlerA implements IHandler { 
  6.   @Override
  7.   public boolean handle() { 
  8.     boolean handleResult = false;
  9.     //...
  10.     return handleResult;
  11.   }
  12. }
  14. public class HandlerB implements IHandler { 
  15.   @Override
  16.   public boolean handle() { 
  17.     boolean handleResult = false;
  18.     //...
  19.     return handleResult;
  20.   }
  21. }
  23. public class HandlerChain { 
  24.   private List<IHandler> handlers = new ArrayList<>();
  26.   public void addHandler(IHandler handler) { 
  27.     this.handlers.add(handler);
  28.   }
  30.   public void handle() { 
  31.     for (IHandler handler : handlers) { 
  32.       boolean handleResult = handler.handle();
  33.       if (handleResult) { 
  34.         break;
  35.       }
  36.     }
  37.   }
  38. }
  40. // 使用举例
  41. public class Application { 
  42.   public static void main(String[] args) { 
  43.     HandlerChain chain = new HandlerChain();
  44.     chain.addHandler(new HandlerA());
  45.     chain.addHandler(new HandlerB());
  46.     chain.handle();
  47.   }
  48. }

Spring框架中的Interceptor用来实现对HTTP请求进行拦截处理。它与Servlet Filter有所不同，Servlet Filter是Servlet规范的一部分，实现依赖于Web容器。Spring Interceptor是Spring MVC框架的一部分，由Spring MVC来提供实现。客户端发送的请求，会先经过Servlet Filter，然后再经过Spring Interceptor，最后到达具体的业务代码中。具体处理流程如下图所示：

20200606202425740.jpg

对应到Spring Interceptor的源码就是HandlerInterceptor接口和 HandlerExecutionChain。HandlerInterceptor接口源码如下， 对请求的拦截定义为preHandle()方法，对响应的拦截定义为postHandle()方法。

  1. public interface HandlerInterceptor { 
  3.   boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
  4.       throws Exception;
  6.   void postHandle(
  7.       HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
  8.       throws Exception;
  10.   void afterCompletion(
  11.       HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
  12.       throws Exception;
  14. }

以下示例代码，写一个ControllerInterceptor类去实现HandlerInterceptor接口。

  1. @Component
  2. public class ControllerInterceptor implements HandlerInterceptor { 
  4.   @Override
  5.   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
  6.     System.out.println("拦截客户端发送来的请求.");
  7.     return true; // 继续后续的处理
  8.   }
  10.   @Override
  11.   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
  12.     System.out.println("拦截发送给客户端的响应.");
  13.   }
  15.   @Override
  16.   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
  17.     System.out.println("这里总是被执行.");
  18.   }
  19. }

向Spring MVC框架配置自定义的ControllerInterceptor。

  1. @Configuration
  2. public class WebMvcConfigurer extends WebMvcConfigurerAdapter { 
  4.     @Resource
  5.     private ControllerInterceptor controllerInterceptor;
  7.     @Override
  8.     public void addInterceptors(InterceptorRegistry registry) { 
  9.         registry.addInterceptor(controlToolInterceptor).addPathPatterns("/**");
  10.         super.addInterceptors(registry);
  11.     }
  12. }

Spring Interceptor也是基于职责链模式实现的，HandlerExecutionChain类就是职责链模式中的处理器链。它的实现不需要使用递归，主要是因为它将请求和响应的拦截工作，拆分到了两个函数中去实现。HandlerExecutionChain的关键源码摘抄如下：

  1. public class HandlerExecutionChain { 
  3.    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
  5.    private final Object handler;
  7.    private HandlerInterceptor[] interceptors;
  9.    private List<HandlerInterceptor> interceptorList;
  11.    private int interceptorIndex = -1;
  13.    public HandlerExecutionChain(Object handler) { 
  14.       this(handler, (HandlerInterceptor[]) null);
  15.    }
  17.    public HandlerExecutionChain(Object handler, HandlerInterceptor... interceptors) { 
  18.       if (handler instanceof HandlerExecutionChain) { 
  19.          HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;
  20.          this.handler = originalChain.getHandler();
  21.          this.interceptorList = new ArrayList<HandlerInterceptor>();
  22.          CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);
  23.          CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);
  24.       } else { 
  25.          this.handler = handler;
  26.          this.interceptors = interceptors;
  27.       }
  28.    }
  30.    public void addInterceptor(HandlerInterceptor interceptor) { 
  31.       initInterceptorList().add(interceptor);
  32.    }
  34.    public void addInterceptors(HandlerInterceptor... interceptors) { 
  35.       if (!ObjectUtils.isEmpty(interceptors)) { 
  36.          CollectionUtils.mergeArrayIntoCollection(interceptors, initInterceptorList());
  37.       }
  38.    }
  40.    private List<HandlerInterceptor> initInterceptorList() { 
  41.       if (this.interceptorList == null) { 
  42.          this.interceptorList = new ArrayList<HandlerInterceptor>();
  43.          if (this.interceptors != null) { 
  44.             // An interceptor array specified through the constructor
  45.             CollectionUtils.mergeArrayIntoCollection(this.interceptors, this.interceptorList);
  46.          }
  47.       }
  48.       this.interceptors = null;
  49.       return this.interceptorList;
  50.    }
  52.    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception { 
  53.       HandlerInterceptor[] interceptors = getInterceptors();
  54.       if (!ObjectUtils.isEmpty(interceptors)) { 
  55.          for (int i = 0; i < interceptors.length; i++) { 
  56.             HandlerInterceptor interceptor = interceptors[i];
  57.             if (!interceptor.preHandle(request, response, this.handler)) { 
  58.                triggerAfterCompletion(request, response, null);
  59.                return false;
  60.             }
  61.             this.interceptorIndex = i;
  62.          }
  63.       }
  64.       return true;
  65.    }
  67.    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception { 
  68.       HandlerInterceptor[] interceptors = getInterceptors();
  69.       if (!ObjectUtils.isEmpty(interceptors)) { 
  70.          for (int i = interceptors.length - 1; i >= 0; i--) { 
  71.             HandlerInterceptor interceptor = interceptors[i];
  72.             interceptor.postHandle(request, response, this.handler, mv);
  73.          }
  74.       }
  75.    }
  77.    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
  78.          throws Exception { 
  80.       HandlerInterceptor[] interceptors = getInterceptors();
  81.       if (!ObjectUtils.isEmpty(interceptors)) { 
  82.          for (int i = this.interceptorIndex; i >= 0; i--) { 
  83.             HandlerInterceptor interceptor = interceptors[i];
  84.             try { 
  85.                interceptor.afterCompletion(request, response, this.handler, ex);
  86.             }
  87.             catch (Throwable ex2) { 
  88.                logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
  89.             }
  90.          }
  91.       }
  92.    }
  94. }

在Spring框架中，DispatcherServlet的doDispatch()方法用来分发请求，它在真正的业务逻辑执行前后，会执行HandlerExecutionChain中的 applyPreHandle()和applyPostHandle()函数，用来实现对请求与响应的拦截功能。

职责链模式常用在框架开发中，用来实现框架的过滤器、拦截器功能，让框架的使用者在不需要修改框架源码的情况下，添加新的过滤拦截功能，体现了对扩展开放、对修改关闭的设计原则。

发表评论

表情：
评论列表 （有 0 条评论，99人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring用到的设计模式

    Design Patterns(设计模式) 表示面向对象软件开发中最好的计算机编程实践。 Spring 框架中广泛使用了不同类型的设计模式，下面我们来看看到底有哪些设计模式?

    水深无声水深无声/ 0 赞/ 351 阅读