折腾Java设计模式之责任链模式

Posted 大萌小路

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了折腾Java设计模式之责任链模式相关的知识，希望对你有一定的参考价值。

责任链模式

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

简介

意图 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

主要解决 职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

何时使用 在处理消息的时候以过滤很多道。

如何解决 拦截的类都实现统一接口。

关键代码 Handler 里面聚合它自己，在 handleRequest 里判断是否合适，如果没达到条件则向下传递。

纯责任链与不纯责任链

  • 纯：纯责任链中的节点只有两种行为，一处理责任，二将责任传递到下一个节点。不允许出现某一个节点处理部分或全部责任后又将责任向下传递的情况。

  • 不纯：允许某个请求被一个节点处理部分责任后再向下传递，或者处理完后其后续节点可以继续处理该责任，而且一个责任可以最终不被任何节点所处理。

主要角色

  • Handler（抽象处理者）： 定义一个处理请求的接口，提供对后续处理者的引用

  • ConcreteHandler（具体处理者）： 抽象处理者的子类，处理用户请求，可选将请求处理掉还是传给下家；在具体处理者中可以访问链中下一个对象，以便请求的转发

应用实例

1、红楼梦中的 "击鼓传花"。 

2、JS 中的事件冒泡。 

3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

优点

1、降低耦合度。它将请求的发送者和接收者解耦。 

2、简化了对象。使得对象不需要知道链的结构。

3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 

4、增加新的请求处理类很方便。

缺点

1、不能保证请求一定被接收。

2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。

3、可能不容易观察运行时的特征，有碍于除错。

使用场景

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 

3、可动态指定一组对象处理请求。

Github 项目描述

跳转到我的责任链设计模式源码

1. 出行方式

travel 包里主要对出行方式的责任链模式。跟进用户身上的钱，在优先级如飞机 -> 火车 -> 大巴的顺序下选择对应的出行模式。

 
   
   
 
    
  
    
    
  
  1. public class Application {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     public static void main(String[] args) {
    4. 
  
    
    
  
  4.         Handler planeHandler = new PlaneHandler();
    5. 
  
    
    
  
  5.         Handler trainHandler = new TrainHandler();
    6. 
  
    
    
  
  6.         Handler busHandler = new BusHandler();
    7. 
  
    
    
  
  7.         planeHandler.setNext(trainHandler);
    8. 
  
    
    
  
  8.         trainHandler.setNext(busHandler);
    9. 
  
    
    
  
    10. 
  
    
    
  
  10.         planeHandler.handleRequest("老王", 40d);
    11. 
  
    
    
  
  11.         planeHandler.handleRequest("张三", 140d);
    12. 
  
    
    
  
  12.         planeHandler.handleRequest("李四", 240d);
    13. 
  
    
    
  
  13.         planeHandler.handleRequest("吴老五", 340d);
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16.

抽象处理

 
   
   
 
    
  
    
    
  
  1. @Data
    2. 
  
    
    
  
  2. public abstract class Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     /**
    5. 
  
    
    
  
  5.      * 下一个链节点
    6. 
  
    
    
  
  6.      */
    7. 
  
    
    
  
  7.     protected Handler next;
    8. 
  
    
    
  
    9. 
  
    
    
  
  9.     public abstract void handleRequest(String name, Double wallet);
    10. 
  
    
    
  
  10. }
    11.

具体的处理者（飞机、火车、大巴）

 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class PlaneHandler extends Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 280d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.             log.info("{}身上的钱可以坐飞机。", name);
    10. 
  
    
    
  
  10.             return;
    11. 
  
    
    
  
  11.         }
    12. 
  
    
    
  
  12.         if (Objects.nonNull(next)) {
    13. 
  
    
    
  
  13.             next.handleRequest(name, wallet);
    14. 
  
    
    
  
  14.             return;
    15. 
  
    
    
  
  15.         }
    16. 
  
    
    
  
  16.         log.info("{}钱不够，只能徒步啦", name);
    17. 
  
    
    
  
  17.     }
    18. 
  
    
    
  
  18. }
    19. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class TrainHandler extends Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 149.99d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.            log.info("{}身上的钱只能坐火车。", name);
    10. 
  
    
    
  
  10.            return;
    11. 
  
    
    
  
  11.         }
    12. 
  
    
    
  
  12.         if (Objects.nonNull(next)) {
    13. 
  
    
    
  
  13.             next.handleRequest(name, wallet);
    14. 
  
    
    
  
  14.             return;
    15. 
  
    
    
  
  15.         }
    16. 
  
    
    
  
  16.         log.info("{}钱不够，只能徒步啦", name);
    17. 
  
    
    
  
  17.     }
    18. 
  
    
    
  
  18. }
    19. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class BusHandler extends Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 59.99d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.             log.info("{}身上的钱只能坐大巴。", name);
    10. 
  
    
    
  
  10.             return;
    11. 
  
    
    
  
  11.         }
    12. 
  
    
    
  
  12.         if (Objects.nonNull(next)) {
    13. 
  
    
    
  
  13.             next.handleRequest(name, wallet);
    14. 
  
    
    
  
  14.             return;
    15. 
  
    
    
  
  15.         }
    16. 
  
    
    
  
  16.         log.info("{}钱不够，只能徒步啦", name);
    17. 
  
    
    
  
  17.     }
    18. 
  
    
    
  
  18. }
    19.

2. 出行方式 2，参考 Filter 链的写法

travel2 包是对 travel 包的重新写法。

 
   
   
 
    
  
    
    
  
  1. public class Application {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     public static void main(String[] args) {
    4. 
  
    
    
  
  4.         HandlerChain chain = new HandlerChain();
    5. 
  
    
    
  
  5.         Handler planeHandler = new PlaneHandler();
    6. 
  
    
    
  
  6.         Handler trainHandler = new TrainHandler();
    7. 
  
    
    
  
  7.         Handler busHandler = new BusHandler();
    8. 
  
    
    
  
  8.         chain.addHandler(planeHandler);
    9. 
  
    
    
  
  9.         chain.addHandler(trainHandler);
    10. 
  
    
    
  
  10.         chain.addHandler(busHandler);
    11. 
  
    
    
  
    12. 
  
    
    
  
  12.         chain.handle("老王", 40d);
    13. 
  
    
    
  
  13.         chain.handle("张三", 140d);
    14. 
  
    
    
  
  14.         chain.handle("李四", 240d);
    15. 
  
    
    
  
  15.         chain.handle("吴老五", 340d);
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
  17. }
    18.

抽象处理者

 
   
   
 
    
  
    
    
  
  1. public interface Handler {
    2. 
  
    
    
  
    3. 
  
    
    
  
  3.     void handleRequest(String name, Double wallet, HandlerChain chain);
    4. 
  
    
    
  
  4. }
    5.

具体处理者（飞机、火车、大巴）

 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class PlaneHandler implements Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 280d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet, HandlerChain chain) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.             log.info("{}身上的钱可以坐飞机。", name);
    10. 
  
    
    
  
  10.             chain.reuse();
    11. 
  
    
    
  
  11.             return;
    12. 
  
    
    
  
  12.         }
    13. 
  
    
    
  
  13.         chain.handle(name, wallet);
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class TrainHandler implements Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 149.99d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet, HandlerChain chain) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.             log.info("{}身上的钱只能坐火车。", name);
    10. 
  
    
    
  
  10.             chain.reuse();
    11. 
  
    
    
  
  11.             return;
    12. 
  
    
    
  
  12.         }
    13. 
  
    
    
  
  13.         chain.handle(name, wallet);
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class BusHandler implements Handler {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private double price = 59.99d;
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     @Override
    7. 
  
    
    
  
  7.     public void handleRequest(String name, Double wallet, HandlerChain chain) {
    8. 
  
    
    
  
  8.         if (price <= wallet) {
    9. 
  
    
    
  
  9.             log.info("{}身上的钱只能坐大巴。", name);
    10. 
  
    
    
  
  10.             chain.reuse();
    11. 
  
    
    
  
  11.             return;
    12. 
  
    
    
  
  12.         }
    13. 
  
    
    
  
  13.         chain.handle(name, wallet);
    14. 
  
    
    
  
  14.     }
    15. 
  
    
    
  
  15. }
    16.

责任链管理者

 
   
   
 
    
  
    
    
  
  1. @Slf4j
    2. 
  
    
    
  
  2. public class HandlerChain {
    3. 
  
    
    
  
    4. 
  
    
    
  
  4.     private List<Handler> handlerList = new ArrayList<>();
    5. 
  
    
    
  
    6. 
  
    
    
  
  6.     /**
    7. 
  
    
    
  
  7.      * 维护当前链上位置
    8. 
  
    
    
  
  8.      */
    9. 
  
    
    
  
  9.     private int pos;
    10. 
  
    
    
  
    11. 
  
    
    
  
  11.     /**
    12. 
  
    
    
  
  12.      * 链的长度
    13. 
  
    
    
  
  13.      */
    14. 
  
    
    
  
  14.     private int handlerLength;
    15. 
  
    
    
  
    16. 
  
    
    
  
  16.     public void addHandler(Handler handler) {
    17. 
  
    
    
  
  17.         handlerList.add(handler);
    18. 
  
    
    
  
  18.         handlerLength = handlerList.size();
    19. 
  
    
    
  
  19.     }
    20. 
  
    
    
  
    21. 
  
    
    
  
  21.     public void handle(String name, double wallet) {
    22. 
  
    
    
  
  22.         if (CollectionUtils.isEmpty(handlerList)) {
    23. 
  
    
    
  
  23.             log.error("有钱，但没提供服务，{}也估计就只能步行了。", name);
    24. 
  
    
    
  
  24.             return;
    25. 
  
    
    
  
  25.         }
    26. 
  
    
    
  
  26.         if (pos >= handlerLength) {
    27. 
  
    
    
  
  27.             log.error("身上钱不够，{}也估计就只能步行了。", name);
    28. 
  
    
    
  
  28.             reuse();
    29. 
  
    
    
  
  29.             return;
    30. 
  
    
    
  
  30.         }
    31. 
  
    
    
  
  31.         Handler handler = handlerList.get(pos++);
    32. 
  
    
    
  
  32.         if (Objects.isNull(handler)) {
    33. 
  
    
    
  
  33.             log.error("假服务，{}也估计就只能步行了。", name);
    34. 
  
    
    
  
  34.             reuse();
    35. 
  
    
    
  
  35.             return;
    36. 
  
    
    
  
  36.         }
    37. 
  
    
    
  
    38. 
  
    
    
  
  38.         handler.handleRequest(name, wallet, this);
    39. 
  
    
    
  
  39.     }
    40. 
  
    
    
  
    41. 
  
    
    
  
  41.     /**
    42. 
  
    
    
  
  42.      * 链重新使用
    43. 
  
    
    
  
  43.      */
    44. 
  
    
    
  
  44.     public void reuse() {
    45. 
  
    
    
  
  45.         pos = 0;
    46. 
  
    
    
  
  46.     }
    47. 
  
    
    
  
  47. }
    48.

学习 Web 项目的 Filter

待补充...

补充补充遗留的 Filter 过滤器中的责任链处理。

本次主要是对 Tomcat 中的 Filter 处理简单的梳理，如有不正确的地方，还望指出来，大家互勉，共进。

老项目大家可以在 web.xml 中配置 filter，现使用 Springboot 后，也有两种配置 filter 方式，通过创建 FilterRegistrationBean 的方式和通过注解 @WebFilter+@ServletComponentScan 的方式。

三个主要的角色

FIlter，不多介绍了。

FilterChain servlet 容器提供的开发调用链的过滤请求的资源。通过调用下一个 filter 实现过滤，在整体链上。

FilterConfig filter 的配置器，在 servlet 容器在 Filter 初始化的时候传递信息。

具体的 filter，主要说说 Spring 中的两个抽象 Filter，GenericFilterBean 和 OncePerRequestFilter。

前者主要是做 init 和 destroy 的操作，重点还是 init 方法，destroy 只是空实现而已。

后者主要是做真正的 doFilter 操作，也是我们在 Spring 中创建 Filter 通常继承的。

而 ApplicationFilterChain 就算 Tomcat 中的 FilterChain 实现。

 
   
   
 
    
  
    
    
  
  1.     //The int which is used to maintain the current position in the filter chain.
    2. 
  
    
    
  
  2.     
    3. 
  
    
    
  
  3.     private int pos = 0;
    4. 
  
    
    
  

    5. 
  
    
    
  
  5.     //The int which gives the current number of filters in the chain.
    6. 
  
    
    
  

    7. 
  
    
    
  
  7.     private int n = 0;
    8. 
  
    
    
  
    9. 
  
    
    
  
  9. @Override
    10. 
  
    
    
  
  10. public void doFilter(ServletRequest request, ServletResponse response)
    11. 
  
    
    
  
  11.     throws IOException, ServletException {
    12. 
  
    
    
  
  12.     //安全相关的，暂不关注
    13. 
  
    
    
  
  13.     if( Globals.IS_SECURITY_ENABLED ) {
    14. 
  
    
    
  
  14.         final ServletRequest req = request;
    15. 
  
    
    
  
  15.         final ServletResponse res = response;
    16. 
  
    
    
  
  16.         try {
    17. 
  
    
    
  
  17.             java.security.AccessController.doPrivileged(
    18. 
  
    
    
  
  18.                 new java.security.PrivilegedExceptionAction<Void>() {
    19. 
  
    
    
  
  19.                     @Override
    20. 
  
    
    
  
  20.                     public Void run()
    21. 
  
    
    
  
  21.                         throws ServletException, IOException {
    22. 
  
    
    
  
  22.                         internalDoFilter(req,res);
    23. 
  
    
    
  
  23.                         return null;
    24. 
  
    
    
  
  24.                     }
    25. 
  
    
    
  
  25.                 }
    26. 
  
    
    
  
  26.             );
    27. 
  
    
    
  
  27.         } catch( PrivilegedActionException pe) {
    28. 
  
    
    
  
  28.             Exception e = pe.getException();
    29. 
  
    
    
  
  29.             if (e instanceof ServletException)
    30. 
  
    
    
  
  30.                 throw (ServletException) e;
    31. 
  
    
    
  
  31.             else if (e instanceof IOException)
    32. 
  
    
    
  
  32.                 throw (IOException) e;
    33. 
  
    
    
  
  33.             else if (e instanceof RuntimeException)
    34. 
  
    
    
  
  34.                 throw (RuntimeException) e;
    35. 
  
    
    
  
  35.             else
    36. 
  
    
    
  
  36.                 throw new ServletException(e.getMessage(), e);
    37. 
  
    
    
  
  37.         }
    38. 
  
    
    
  
  38.     } else {
    39. 
  
    
    
  
  39.         //真正的doFilter
    40. 
  
    
    
  
  40.         internalDoFilter(request,response);
    41. 
  
    
    
  
  41.     }
    42. 
  
    
    
  
  42. }
    43. 
  
    
    
  
    44. 
  
    
    
  
    45. 
  
    
    
  
  45. private void internalDoFilter(ServletRequest request,
    46. 
  
    
    
  
  46.                               ServletResponse response)
    47. 
  
    
    
  
  47.     throws IOException, ServletException {
    48. 
  
    
    
  
  48.     //pos 调用链中当前连接点所在的位置
    49. 
  
    
    
  
  49.     //n 调用链总节点长度
    50. 
  
    
    
  
  50.     // Call the next filter if there is one
    51. 
  
    
    
  
  51.     if (pos < n) {
    52. 
  
    
    
  
  52.         //对节点进行自增 pos++
    53. 
  
    
    
  
  53.         ApplicationFilterConfig filterConfig = filters[pos++];
    54. 
  
    
    
  
  54.         try {
    55. 
  
    
    
  
  55.             //当前节点小于总长度后，从filter配置类中取出filter
    56. 
  
    
    
  

    57. 
  
    
    
  
  57.             Filter filter = filterConfig.getFilter();
    58. 
  
    
    
  
    59. 
  
    
    
  
  59.             if (request.isAsyncSupported() && "false".equalsIgnoreCase(
    60. 
  
    
    
  
  60.                     filterConfig.getFilterDef().getAsyncSupported())) {
    61. 
  
    
    
  
  61.                 request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
    62. 
  
    
    
  
  62.             }
    63. 
  
    
    
  
  63.             if( Globals.IS_SECURITY_ENABLED ) {
    64. 
  
    
    
  
  64.                 final ServletRequest req = request;
    65. 
  
    
    
  
  65.                 final ServletResponse res = response;
    66. 
  
    
    
  
  66.                 Principal principal =
    67. 
  
    
    
  
  67.                     ((HttpServletRequest) req).getUserPrincipal();
    68. 
  
    
    
  
    69. 
  
    
    
  
  69.                 Object[] args = new Object[]{req, res, this};
    70. 
  
    
    
  
  70.                 SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
    71. 
  
    
    
  
  71.             } else {
    72. 
  
    
    
  
  72.                 //真正的filter
    73. 
  
    
    
  
  73.                 filter.doFilter(request, response, this);
    74. 
  
    
    
  
  74.             }
    75. 
  
    
    
  
  75.         } catch (IOException | ServletException | RuntimeException e) {
    76. 
  
    
    
  
  76.             throw e;
    77. 
  
    
    
  
  77.         } catch (Throwable e) {
    78. 
  
    
    
  
  78.             e = ExceptionUtils.unwrapInvocationTargetException(e);
    79. 
  
    
    
  
  79.             ExceptionUtils.handleThrowable(e);
    80. 
  
    
    
  
  80.             throw new ServletException(sm.getString("filterChain.filter"), e);
    81. 
  
    
    
  
  81.         }
    82. 
  
    
    
  
  82.         return;
    83. 
  
    
    
  
  83.     }
    84. 
  
    
    
  
    85. 
  
    
    
  
  85.     //到了调用链结尾处，就真正调用servlet实例的servlet.service(request, response);
    86. 
  
    
    
  
  86.     
    87. 
  
    
    
  
  87.     try {
    88. 
  
    
    
  
  88.         if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
    89. 
  
    
    
  
  89.             lastServicedRequest.set(request);
    90. 
  
    
    
  
  90.             lastServicedResponse.set(response);
    91. 
  
    
    
  
  91.         }
    92. 
  
    
    
  
    93. 
  
    
    
  
  93.         if (request.isAsyncSupported() && !servletSupportsAsync) {
    94. 
  
    
    
  
  94.             request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
    95. 
  
    
    
  
  95.                     Boolean.FALSE);
    96. 
  
    
    
  
  96.         }
    97. 
  
    
    
  
  97.         // Use potentially wrapped request from this point
    98. 
  
    
    
  
  98.         
    99. 
  
    
    
  
  99.         if ((request instanceof HttpServletRequest) &&
    100. 
  
    
    
  
  100.                 (response instanceof HttpServletResponse) &&
    101. 
  
    
    
  
  101.                 Globals.IS_SECURITY_ENABLED ) {
    102. 
  
    
    
  
  102.             final ServletRequest req = request;
    103. 
  
    
    
  
  103.             final ServletResponse res = response;
    104. 
  
    
    
  
  104.             Principal principal =
    105. 
  
    
    
  
  105.                 ((HttpServletRequest) req).getUserPrincipal();
    106. 
  
    
    
  
  106.             Object[] args = new Object[]{req, res};
    107. 
  
    
    
  
  107.             SecurityUtil.doAsPrivilege("service",
    108. 
  
    
    
  
  108.                                        servlet,
    109. 
  
    
    
  
  109.                                        classTypeUsedInService,
    110. 
  
    
    
  
  110.                                        args,
    111. 
  
    
    
  
  111.                                        principal);
    112. 
  
    
    
  
  112.         } else {
    113. 
  
    
    
  
  113.             servlet.service(request, response);
    114. 
  
    
    
  
  114.         }
    115. 
  
    
    
  
  115.     } catch (IOException | ServletException | RuntimeException e) {
    116. 
  
    
    
  
  116.         throw e;
    117. 
  
    
    
  
  117.     } catch (Throwable e) {
    118. 
  
    
    
  
  118.         e = ExceptionUtils.unwrapInvocationTargetException(e);
    119. 
  
    
    
  
  119.         ExceptionUtils.handleThrowable(e);
    120. 
  
    
    
  
  120.         throw new ServletException(sm.getString("filterChain.servlet"), e);
    121. 
  
    
    
  
  121.     } finally {
    122. 
  
    
    
  
  122.         if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
    123. 
  
    
    
  
  123.             lastServicedRequest.set(null);
    124. 
  
    
    
  
  124.             lastServicedResponse.set(null);
    125. 
  
    
    
  
  125.         }
    126. 
  
    
    
  
  126.     }
    127. 
  
    
    
  
  127. }
    128. 
  
    
    
  
    129. 
  
    
    
  
  129. //重复使用filter调用链，pos重设为0
    130. 
  
    
    
  
  130. void reuse() {
    131. 
  
    
    
  
  131.     pos = 0;
    132. 
  
    
    
  
  132. }
    133.

重点从 ApplicationFilterChain 中挑出几个重要的方法拿出来分析下 Filter 的调用链，其实还有几处没有具体讲到，ApplicationFilterChain 是合适创建的，Filter 是怎么加入到 ApplicationFilterChain 中的。这涉及到 Tomcat 是怎样加载 Content 的，下次分析 Tomcat 的时候，再来具体分析，它是如何运作的，如何加载 web.xml。

以上是关于折腾Java设计模式之责任链模式的主要内容，如果未能解决你的问题，请参考以下文章

java23种设计模式之十：责任链模式

Java责任链模式之总有你想不到的知识

JAVA设计模式之责任链模式

Java设计模式之八 ----- 责任链模式和命令模式

Java 设计模式之责任链学习与掌握

Java 设计模式之责任链学习与掌握