透过源码学习设计模式1—Servlet Filter和责任链模式

Posted java达人

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了透过源码学习设计模式1—Servlet Filter和责任链模式相关的知识，希望对你有一定的参考价值。


Servlet filter 一瞥

相信大家都熟悉Servlet中Filter过滤器，我们可以在servlet和servlet容器之间插入Filter过滤器来包装、预处理请求，或者包装、处理响应。过滤器本身不知道自己的顺序。而是由FilterChain按照web.xml中的配置顺序执行的，确切的说，按照<filter-mapping> 的顺序执行的。而调用完chain.doFilter()方法后，即当filter链中的filter都按顺序执行完毕，像堆栈一样，filter又从最后的一个开始执行。

Filter实现类的示例如下：

 
   
   
 
    
  
    
    
  
  1. import javax.servlet.*;
    2. 
  
    
    
  

    3. 
  
    
    
  
  3. import java.util.*;
    4. 
  
    
    
  

    5. 
  
    
    
  
  5. //实现 Filter 类
    6. 
  
    
    
  

    7. 
  
    
    
  
  7. @Slf4j
    8. 
  
    
    
  

    9. 
  
    
    
  
  9. public class LogFilter implements Filter {
    10. 
  
    
    
  

    11. 
  
    
    
  
  11.  public void init(FilterConfig config) throws ServletException {
    12. 
  
    
    
  

    13. 
  
    
    
  
  13.  // 获取初始化参数
    14. 
  
    
    
  

    15. 
  
    
    
  
  15.  String preInfo = config.getInitParameter(“preInfo");
    16. 
  
    
    
  

    17. 
  
    
    
  
  17.  // 输出初始化参数
    18. 
  
    
    
  

    19. 
  
    
    
  
  19.  log.info("preInfo: " + preInfo);
    20. 
  
    
    
  

    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  

    23. 
  
    
    
  
  23.  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws java.io.IOException, ServletException {
    24. 
  
    
    
  

    25. 
  
    
    
  
  25.  // 取得根目录所对应的绝对路径:
    26. 
  
    
    
  

    27. 
  
    
    
  
  27.  String currentURL = request.getRequestURI(); 
    28. 
  
    
    
  

    29. 
  
    
    
  
  29.  currentURL = currentURL.replaceAll("//+","/");
    30. 
  
    
    
  

    31. 
  
    
    
  
  31. 
  
    
    
  

    33. 
  
    
    
  
  33.  // 把请求传回过滤链
    34. 
  
    
    
  

    35. 
  
    
    
  
  35.  chain.doFilter(request,response);
    36. 
  
    
    
  

    37. 
  
    
    
  
  37.  }
    38. 
  
    
    
  

    39. 
  
    
    
  
  39.  public void destroy( ){
    40. 
  
    
    
  

    41. 
  
    
    
  
  41.  /* 在 Filter 实例被 Web 容器从服务移除之前调用 */
    42. 
  
    
    
  

    43. 
  
    
    
  
  43.  }
    44. 
  
    
    
  

    45. 
  
    
    
  
  45. }
    46.

每个Filter过滤器实现javax.servlet.Filter接口，其中包含一个doFilter()方法，该方法接受一个request,resonse对以及filterChain作为参数输入，filterChain实现javax.servlet.FilterChain接口(由servlet容器提供)，当请求到来时，它将会管理与该请求相关的一系列过滤器的执行，当过滤器执行完毕，doFilter接下来就会调用servlet的service()方法。

想象一下，如果没有filter机制，我们可能会把所有的逻辑写在一处，里面堆积着一堆if….else，这样是违反“单一职责原则”的，就算我们把这些逻辑拆分为多个类，假如后期增加或删除某些节点，或者调整节点顺序，就要修改源码，进行严格测试。而servlet filter使用了责任链模式，很好地解决了这个设计问题。

责任链模式

责任链模式包含一份请求对象和一系列执行对象，每个执行对象都定义了可以执行哪些请求对象，剩下的请求对象就传递给链中的下一个执行对象。也可以添加新的执行对象到链尾，这样责任链和if ... else if ... else if ....... else … endif 在语义上比较类似。但他的条件模块可以在运行时动态编排和配置。

责任链模式解决的问题：

  1. 请求者和接受者松散耦合

在责任链模式中，请求者并不知道接受者是谁，也不知道具体如何处理。请求者只负责向责任链发出请求就可以了，该模式下可以有多个接受者处理对象，每个接受者只负责处理自己的部分，其他的就交给其他的接受者去处理。请求在链中传递，接受者处理该请求，或者传递给链中下一个接受者。请求者不再和特定接受者紧密耦合。

   2. 通过改变链内成员的或者调整它们的次序，允许你动态地新增或删除责任。

细看FilterChain

我们以tomcat中的ApplicationFilterFactory和ApplicationFilterChain为例，看看他做了什么，首先，我们看看它是怎么样动态编排一条责任链的呢：

ApplicationFilterFactory 的createFilterChain方法：

 
   
   
 
    
  
    
    
  
  1. public static ApplicationFilterChain createFilterChain(ServletRequest request,
    2. 
  
    
    
  
  2.  Wrapper wrapper, Servlet servlet) {
    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  // 如果没有相关servlet，返回null
    5. 
  
    
    
  
  5.  if (servlet == null)
    6. 
  
    
    
  
  6.  return null;
    7. 
  
    
    
  

    8. 
  
    
    
  
  8.  // 创建、初始化一个FilterChain对象
    9. 
  
    
    
  
  9.  ApplicationFilterChain filterChain = null;
    10. 
  
    
    
  
  10.  if (request instanceof Request) {
    11. 
  
    
    
  
  11.  Request req = (Request) request;
    12. 
  
    
    
  
  12.  if (Globals.IS_SECURITY_ENABLED) {
    13. 
  
    
    
  
  13.  // Security: Do not recycle
    14. 
  
    
    
  
  14.  filterChain = new ApplicationFilterChain();
    15. 
  
    
    
  
  15.  } else {
    16. 
  
    
    
  
  16.  filterChain = (ApplicationFilterChain) req.getFilterChain();
    17. 
  
    
    
  
  17.  if (filterChain == null) {
    18. 
  
    
    
  
  18.  filterChain = new ApplicationFilterChain();
    19. 
  
    
    
  
  19.  req.setFilterChain(filterChain);
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22.  } else {
    23. 
  
    
    
  
  23.  // Request dispatcher in use
    24. 
  
    
    
  
  24.  filterChain = new ApplicationFilterChain();
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  

    27. 
  
    
    
  
  27.  filterChain.setServlet(servlet);
    28. 
  
    
    
  
  28.  filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());
    29. 
  
    
    
  

    30. 
  
    
    
  
  30.  // 获取上下文中的filterMapping
    31. 
  
    
    
  
  31.  StandardContext context = (StandardContext) wrapper.getParent();
    32. 
  
    
    
  
  32.  FilterMap filterMaps[] = context.findFilterMaps();
    33. 
  
    
    
  

    34. 
  
    
    
  
  34.  // 如果没有 filter mappings, 完成。
    35. 
  
    
    
  
  35.  if ((filterMaps == null) || (filterMaps.length == 0))
    36. 
  
    
    
  
  36.  return (filterChain);
    37. 
  
    
    
  

    38. 
  
    
    
  
  38.  // Acquire the information we will need to match filter mappings
    39. 
  
    
    
  
  39.  DispatcherType dispatcher =
    40. 
  
    
    
  
  40.  (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
    41. 
  
    
    
  

    42. 
  
    
    
  
  42.  String requestPath = null;
    43. 
  
    
    
  
  43.  Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
    44. 
  
    
    
  
  44.  if (attribute != null){
    45. 
  
    
    
  
  45.  requestPath = attribute.toString();
    46. 
  
    
    
  
  46.  }
    47. 
  
    
    
  

    48. 
  
    
    
  
  48.  String servletName = wrapper.getName();
    49. 
  
    
    
  

    50. 
  
    
    
  
  50.  // 添加相关path-mapped的filter到filterChain
    51. 
  
    
    
  
  51.  for (int i = 0; i < filterMaps.length; i++) {
    52. 
  
    
    
  
  52.  if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
    53. 
  
    
    
  
  53.  continue;
    54. 
  
    
    
  
  54.  }
    55. 
  
    
    
  
  55.  if (!matchFiltersURL(filterMaps[i], requestPath))
    56. 
  
    
    
  
  56.  continue;
    57. 
  
    
    
  
  57.  ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
    58. 
  
    
    
  
  58.  context.findFilterConfig(filterMaps[i].getFilterName());
    59. 
  
    
    
  
  59.  if (filterConfig == null) {
    60. 
  
    
    
  
  60.  // FIXME - log configuration problem
    61. 
  
    
    
  
  61.  continue;
    62. 
  
    
    
  
  62.  }
    63. 
  
    
    
  
  63.  filterChain.addFilter(filterConfig);
    64. 
  
    
    
  
  64.  }
    65. 
  
    
    
  

    66. 
  
    
    
  
  66.  // Add filters that match on servlet name second
    67. 
  
    
    
  
  67.  for (int i = 0; i < filterMaps.length; i++) {
    68. 
  
    
    
  
  68.  if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
    69. 
  
    
    
  
  69.  continue;
    70. 
  
    
    
  
  70.  }
    71. 
  
    
    
  
  71.  if (!matchFiltersServlet(filterMaps[i], servletName))
    72. 
  
    
    
  
  72.  continue;
    73. 
  
    
    
  
  73.  ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
    74. 
  
    
    
  
  74.  context.findFilterConfig(filterMaps[i].getFilterName());
    75. 
  
    
    
  
  75.  if (filterConfig == null) {
    76. 
  
    
    
  
  76.  // FIXME - log configuration problem
    77. 
  
    
    
  
  77.  continue;
    78. 
  
    
    
  
  78.  }
    79. 
  
    
    
  
  79.  filterChain.addFilter(filterConfig);
    80. 
  
    
    
  
  80.  }
    81. 
  
    
    
  

    82. 
  
    
    
  
  82.  // Return the completed filter chain
    83. 
  
    
    
  
  83.  return filterChain;
    84. 
  
    
    
  
  84.  }
    85. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1.  if (!matchFiltersURL(filterMaps[i], requestPath))
    2. 
  
    
    
  
  2.  continue;
    3. 
  
    
    
  
  3.  ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
    4. 
  
    
    
  
  4.  context.findFilterConfig(filterMaps[i].getFilterName());
    5. 
  
    
    
  
  5.  if (filterConfig == null) {
    6. 
  
    
    
  
  6.  // FIXME - log configuration problem
    7. 
  
    
    
  
  7.  continue;
    8. 
  
    
    
  
  8.  }
    9. 
  
    
    
  
  9.  filterChain.addFilter(filterConfig);
    10.

后面截取的这段中，它会按路径(url path)匹配规则筛选Filter，匹配成功，则返回true，将该filter添加到filterChain，否则就不添加，这样针对不同的请求URL，形成了相应的filterChain，达到动态编排的效果。而在链具体执行过程中，FilterChain发挥了巨大的作用，看ApplicationFilterChain部分源码：

ApplicationFilterChain的dofilter方法和internalDoFilter()方法：

 
   
   
 
    
  
    
    
  
  1. /**
    2. 
  
    
    
  
  2.  *触发下一个filter，传递request，response，如果链中没有filter，就触发service()
    3. 
  
    
    
  
  3.  *
    4. 
  
    
    
  
  4.  * @param request The servlet request we are processing
    5. 
  
    
    
  
  5.  * @param response The servlet response we are creating
    6. 
  
    
    
  
  6.  *
    7. 
  
    
    
  
  7.  * @exception IOException if an input/output error occurs
    8. 
  
    
    
  
  8.  * @exception ServletException if a servlet exception occurs
    9. 
  
    
    
  
  9.  */
    10. 
  
    
    
  
  10.  @Override
    11. 
  
    
    
  
  11.  public void doFilter(ServletRequest request, ServletResponse response)
    12. 
  
    
    
  
  12.  throws IOException, ServletException {
    13. 
  
    
    
  

    14. 
  
    
    
  
  14.  if( Globals.IS_SECURITY_ENABLED ) {
    15. 
  
    
    
  
  15.  final ServletRequest req = request;
    16. 
  
    
    
  
  16.  final ServletResponse res = response;
    17. 
  
    
    
  
  17.  try {
    18. 
  
    
    
  
  18.  java.security.AccessController.doPrivileged(
    19. 
  
    
    
  
  19.  new java.security.PrivilegedExceptionAction<Void>() {
    20. 
  
    
    
  
  20.  @Override
    21. 
  
    
    
  
  21.  public Void run()
    22. 
  
    
    
  
  22.  throws ServletException, IOException {
    23. 
  
    
    
  
  23.  internalDoFilter(req,res);
    24. 
  
    
    
  
  24.  return null;
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  
  26.  }
    27. 
  
    
    
  
  27.  );
    28. 
  
    
    
  
  28.  } catch( PrivilegedActionException pe) {
    29. 
  
    
    
  
  29.  Exception e = pe.getException();
    30. 
  
    
    
  
  30.  if (e instanceof ServletException)
    31. 
  
    
    
  
  31.  throw (ServletException) e;
    32. 
  
    
    
  
  32.  else if (e instanceof IOException)
    33. 
  
    
    
  
  33.  throw (IOException) e;
    34. 
  
    
    
  
  34.  else if (e instanceof RuntimeException)
    35. 
  
    
    
  
  35.  throw (RuntimeException) e;
    36. 
  
    
    
  
  36.  else
    37. 
  
    
    
  
  37.  throw new ServletException(e.getMessage(), e);
    38. 
  
    
    
  
  38.  }
    39. 
  
    
    
  
  39.  } else {
    40. 
  
    
    
  
  40.  internalDoFilter(request,response);
    41. 
  
    
    
  
  41.  }
    42. 
  
    
    
  
  42.  }
    43. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1.  private void internalDoFilter(ServletRequest request,
    2. 
  
    
    
  
  2.  ServletResponse response)
    3. 
  
    
    
  
  3.  throws IOException, ServletException {
    4. 
  
    
    
  

    5. 
  
    
    
  
  5.  // 如果有，获取下一个过滤器
    6. 
  
    
    
  
  6.  if (pos < n) {
    7. 
  
    
    
  
  7.  ApplicationFilterConfig filterConfig = filters[pos++];
    8. 
  
    
    
  
  8.  try {
    9. 
  
    
    
  
  9.  Filter filter = filterConfig.getFilter();
    10. 
  
    
    
  

    11. 
  
    
    
  
  11.  if (request.isAsyncSupported() && "false".equalsIgnoreCase(
    12. 
  
    
    
  
  12.  filterConfig.getFilterDef().getAsyncSupported())) {
    13. 
  
    
    
  
  13.  request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
    14. 
  
    
    
  
  14.  }
    15. 
  
    
    
  
  15.  if( Globals.IS_SECURITY_ENABLED ) {
    16. 
  
    
    
  
  16.  final ServletRequest req = request;
    17. 
  
    
    
  
  17.  final ServletResponse res = response;
    18. 
  
    
    
  
  18.  Principal principal =
    19. 
  
    
    
  
  19.  ((HttpServletRequest) req).getUserPrincipal();
    20. 
  
    
    
  

    21. 
  
    
    
  
  21.  Object[] args = new Object[]{req, res, this};
    22. 
  
    
    
  
  22.  SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
    23. 
  
    
    
  
  23.  } else {
    24. 
  
    
    
  
  24.  filter.doFilter(request, response, this);
    25. 
  
    
    
  
  25.  }
    26. 
  
    
    
  
  26.  } catch (IOException | ServletException | RuntimeException e) {
    27. 
  
    
    
  
  27.  throw e;
    28. 
  
    
    
  
  28.  } catch (Throwable e) {
    29. 
  
    
    
  
  29.  e = ExceptionUtils.unwrapInvocationTargetException(e);
    30. 
  
    
    
  
  30.  ExceptionUtils.handleThrowable(e);
    31. 
  
    
    
  
  31.  throw new ServletException(sm.getString("filterChain.filter"), e);
    32. 
  
    
    
  
  32.  }
    33. 
  
    
    
  
  33.  return;
    34. 
  
    
    
  
  34.  }
    35. 
  
    
    
  

    36. 
  
    
    
  
  36.  // We fell off the end of the chain -- call the servlet instance
    37. 
  
    
    
  
  37.  try {
    38. 
  
    
    
  
  38.  if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
    39. 
  
    
    
  
  39.  lastServicedRequest.set(request);
    40. 
  
    
    
  
  40.  lastServicedResponse.set(response);
    41. 
  
    
    
  
  41.  }
    42. 
  
    
    
  

    43. 
  
    
    
  
  43.  if (request.isAsyncSupported() && !servletSupportsAsync) {
    44. 
  
    
    
  
  44.  request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
    45. 
  
    
    
  
  45.  Boolean.FALSE);
    46. 
  
    
    
  
  46.  }
    47. 
  
    
    
  
  47.  // Use potentially wrapped request from this point
    48. 
  
    
    
  
  48.  if ((request instanceof HttpServletRequest) &&
    49. 
  
    
    
  
  49.  (response instanceof HttpServletResponse) &&
    50. 
  
    
    
  
  50.  Globals.IS_SECURITY_ENABLED ) {
    51. 
  
    
    
  
  51.  final ServletRequest req = request;
    52. 
  
    
    
  
  52.  final ServletResponse res = response;
    53. 
  
    
    
  
  53.  Principal principal =
    54. 
  
    
    
  
  54.  ((HttpServletRequest) req).getUserPrincipal();
    55. 
  
    
    
  
  55.  Object[] args = new Object[]{req, res};
    56. 
  
    
    
  
  56.  SecurityUtil.doAsPrivilege("service",
    57. 
  
    
    
  
  57.  servlet,
    58. 
  
    
    
  
  58.  classTypeUsedInService,
    59. 
  
    
    
  
  59.  args,
    60. 
  
    
    
  
  60.  principal);
    61. 
  
    
    
  
  61.  } else {
    62. 
  
    
    
  
  62.  servlet.service(request, response);
    63. 
  
    
    
  
  63.  }
    64. 
  
    
    
  
  64.  } catch (IOException | ServletException | RuntimeException e) {
    65. 
  
    
    
  
  65.  throw e;
    66. 
  
    
    
  
  66.  } catch (Throwable e) {
    67. 
  
    
    
  
  67.  e = ExceptionUtils.unwrapInvocationTargetException(e);
    68. 
  
    
    
  
  68.  ExceptionUtils.handleThrowable(e);
    69. 
  
    
    
  
  69.  throw new ServletException(sm.getString("filterChain.servlet"), e);
    70. 
  
    
    
  
  70.  } finally {
    71. 
  
    
    
  
  71.  if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
    72. 
  
    
    
  
  72.  lastServicedRequest.set(null);
    73. 
  
    
    
  
  73.  lastServicedResponse.set(null);
    74. 
  
    
    
  
  74.  }
    75. 
  
    
    
  
  75.  }
    76. 
  
    
    
  
  76.  }
    77.

ApplicationFilterChain 会调用doFilter(request, response)方法，在doFilter里面会调用internalDoFilter(request,response)方法，该方法拿到每个过滤器，然后过滤器调用自身的doFilter(request, response, filterChain)方法(实现了Filter接口)。

Filter接口doFilter定义如下：

 
   
   
 
    
  
    
    
  
  1. public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
    2.

过滤器链里面的filter在调用dofilter完成后，会继续调用chain.doFilter(request,response)方法，而这个chain其实就是ApplicationFilterChain,所以调用过程又回到了上面调用dofilter和调用internalDoFilter方法，以此类推直到里面的过滤器全部执行。通过FilterChain，每个过滤器相当于间接拥有了下一个Filter的引用，将请求在链中传递，接受者处理相应请求或者将请求传递给下一个接受者。


java达人

ID：drjava

（长按或扫码识别）


以上是关于透过源码学习设计模式1—Servlet Filter和责任链模式的主要内容，如果未能解决你的问题，请参考以下文章

学习笔记——Servlet底层源码分析；Servlet接口；ServletConfig接口；

SpringBoot源码学习系列之嵌入式Servlet容器

SpringBoot源码学习系列之嵌入式Servlet容器

RocketMQ源码学习- 1. 入门

Servlet开发

Dubbo 3 深度剖析 - 透过源码认识你