行为型设计模式：职责链模式
职责链模式的原理和实现
将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。
在职责链模式中，多个处理器一次处理同一个请求，形成一个处理链条，链条上的每个处理器各司其职，所以叫职责链模式。
职责链模式有多种实现方式，我们讲解其中一种：用数组保存处理器的方式，
public interface IHandler { boolean handle(); } public class HandlerA implements IHandler { @Override public boolean handle() {
//这块定义这个是标记某个处理器处理完了下一个处理器就不用处理的 boolean handled = false; //... return handled; } } public class HandlerB implements IHandler { @Override public boolean handle() { boolean handled = false; //... return handled; } }
//处理器链 public class HandlerChain { private List<IHandler> handlers = new ArrayList<>();
//将处理器添加到执行链中 public void addHandler(IHandler handler) { this.handlers.add(handler); } public void handle() {
//挨个执行 for (IHandler handler : handlers) { boolean handled = handler.handle();
//其中有一个处理器处理后则跳出不继续执行 if (handled) { break; } } } } // 使用举例 public class Application { public static void main(String[] args) { HandlerChain chain = new HandlerChain(); chain.addHandler(new HandlerA()); chain.addHandler(new HandlerB()); chain.handle(); } }
上面是挨个执行，某个处理完其他就不处理了，也可以去掉其中的判断，那就是挨个处理，比如进行过滤这种需求就要挨个执行。
职责链模式的应用场景举例
处理敏感词这个应用场景中，有两种处理结果，1是不进行发布 2是进行***处理。第一种方式适合用某个处理器进行处理后其他处理器不进行处理，第二种方式就是顺序执行，所有处理器都执行完毕。
下面实现一个第一种情况,第二种情况把其中判断去掉，挨个执行就行。
public interface SensitiveWordFilter { boolean doFilter(Content content); } public class SexyWordFilter implements SensitiveWordFilter { @Override public boolean doFilter(Content content) { boolean legal = true; //... return legal; } } // PoliticalWordFilter、AdsWordFilter类代码结构与SexyWordFilter类似 public class SensitiveWordFilterChain { private List<SensitiveWordFilter> filters = new ArrayList<>(); public void addFilter(SensitiveWordFilter filter) { this.filters.add(filter); } // return true if content doesn't contain sensitive words. public boolean filter(Content content) { for (SensitiveWordFilter filter : filters) { if (!filter.doFilter(content)) { return false; } } return true; } } public class ApplicationDemo { public static void main(String[] args) { SensitiveWordFilterChain filterChain = new SensitiveWordFilterChain(); filterChain.addFilter(new AdsWordFilter()); filterChain.addFilter(new SexyWordFilter()); filterChain.addFilter(new PoliticalWordFilter()); boolean legal = filterChain.filter(new Content()); if (!legal) { // 不发表 } else { // 发表 } } }
为什么要用这种复杂的方式实现？
我们把各个敏感词过滤函数继续拆分出来，设计成独立的类，进一步简化了 SensitiveWordFilter 类，让 SensitiveWordFilter 类的代码不会过多，过复杂。
如果要增加新的过滤器，只需要新添加一个 Filter 类，并且通过 addFilter() 函数将它添加到 FilterChain 中即可，其他代码完全不需要修改。
框架中职责链的应用
职责链模式最常用来开发框架的过滤器和拦截器。今天，我们就通过 Servlet Filter、Spring Interceptor 这两个 Java 开发中常用的组件，来具体讲讲它在框架开发中的应用。
Servlet Filter
Servlet Filter 是 Java Servlet 规范中定义的组件，即过滤器，它可以实现对 HTTP 请求的过滤功能，比如鉴权、限流、记录日志、验证参数等等。因为它是 Servlet 规范的一部分，所以，只要是支持 Servlet 的 Web 容器（比如，Tomcat、Jetty 等），都支持过滤器功能。它的工作原理，如下所示。
在实际项目中，我们该如何使用 Servlet Filter 呢？
添加一个过滤器，我们只需要定义一个实现 javax.servlet.Filter 接口的过滤器类，并且将它配置在 web.xml 配置文件中。
Web 容器启动的时候，会读取 web.xml 中的配置，创建过滤器对象。当有请求到来的时候，会先经过过滤器，然后才由 Servlet 来处理。
public class LogFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { // 在创建Filter时自动调用， // 其中filterConfig包含这个Filter的配置参数，比如name之类的（从配置文件中读取的） } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { System.out.println("拦截客户端发送来的请求."); chain.doFilter(request, response); System.out.println("拦截发送给客户端的响应."); } @Override public void destroy() { // 在销毁Filter时自动调用 } } // 在web.xml配置文件中如下配置： <filter> <filter-name>logFilter</filter-name> <filter-class>com.xzg.cd.LogFilter</filter-class> </filter> <filter-mapping> <filter-name>logFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
public final class ApplicationFilterChain implements FilterChain { private int pos = 0; //当前执行到了哪个filter private int n; //filter的个数 private ApplicationFilterConfig[] filters; private Servlet servlet; @Override public void doFilter(ServletRequest request, ServletResponse response) { if (pos < n) { ApplicationFilterConfig filterConfig = filters[pos++]; Filter filter = filterConfig.getFilter(); filter.doFilter(request, response, this); } else { // filter都处理完毕后，执行servlet servlet.service(request, response); } } public void addFilter(ApplicationFilterConfig filterConfig) { for (ApplicationFilterConfig filter:filters) if (filter==filterConfig) return; if (n == filters.length) {//扩容 ApplicationFilterConfig[] newFilters = new ApplicationFilterConfig[n + INCREMENT]; System.arraycopy(filters, 0, newFilters, 0, n); filters = newFilters; } filters[n++] = filterConfig; } }
这里面可以看到一个递归：filter.doFilter，这样设计的目的是，我们可以在过滤器执行的前后增加实现内容，达到双向拦截，既能拦截客户端发送来的请求，也能拦截发送给客户端的响应的效果。
Spring Interceptor
拦截器，与Servlet Filter不同之处在于，Servlet Filter 是 Servlet 规范的一部分，实现依赖于 Web 容器。
Spring Interceptor 是 Spring MVC 框架的一部分，由 Spring MVC 框架来提供实现。
客户端发送的请求，会先经过 Servlet Filter，然后再经过 Spring Interceptor，最后到达具体的业务代码中。具体如下所示。
在项目中，我们该如何使用 Spring Interceptor 呢？。
LogInterceptor 实现的功能跟刚才的 LogFilter 完全相同，只是实现方式上稍有区别。LogFilter 对请求和响应的拦截是在 doFilter() 一个函数中实现的，而 LogInterceptor 对请求的拦截在 preHandle() 中实现，对响应的拦截在 postHandle() 中实现。示例代码如下
public class LogInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("拦截客户端发送来的请求."); return true; // 继续后续的处理 } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("拦截发送给客户端的响应."); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("这里总是被执行."); } } //在Spring MVC配置文件中配置interceptors <mvc:interceptors> <mvc:interceptor> <mvc:mapping path="/*"/> <bean class="com.xzg.cd.LogInterceptor" /> </mvc:interceptor> </mvc:interceptors>
同样，我们还是来剖析一下，Spring Interceptor 底层是如何实现的。
其中，HandlerExecutionChain 类是职责链模式中的处理器链。它的实现相较于 Tomcat 中的 ApplicationFilterChain 来说，逻辑更加清晰，不需要使用递归来实现，主要是因为它将请求和响应的拦截工作，拆分到了两个函数中实现。HandlerExecutionChain 的源码如下所示，同样，我对代码也进行了一些简化，只保留了关键代码。
public class HandlerExecutionChain { private final Object handler; private HandlerInterceptor[] interceptors; public void addInterceptor(HandlerInterceptor interceptor) { initInterceptorList().add(interceptor); } boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception { HandlerInterceptor[] interceptors = getInterceptors(); if (!ObjectUtils.isEmpty(interceptors)) { for (int i = 0; i < interceptors.length; i++) { HandlerInterceptor interceptor = interceptors[i]; if (!interceptor.preHandle(request, response, this.handler)) { triggerAfterCompletion(request, response, null); return false; } } } return true; } void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception { HandlerInterceptor[] interceptors = 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, Exception ex) throws Exception { HandlerInterceptor[] interceptors = 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 ex2) { logger.error("HandlerInterceptor.afterCompletion threw exception", ex2); } } } } }
在 Spring 框架中，DispatcherServlet 的 doDispatch() 方法来分发请求，它在真正的业务逻辑执行前后，执行 HandlerExecutionChain 中的 applyPreHandle() 和 applyPostHandle() 函数，用来实现拦截的功能。
