责任链模式在tomcat的应用

一、责任链模式
责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
　责任链模式涉及到的角色如下所示：

　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

　　●　　具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

源代码

　　抽象处理者角色

1. public abstract class Handler {
2.     
3.     /**
4.      * 持有后继的责任对象
5.      */
6.     protected Handler successor;
7.     /**
8.      * 示意处理请求的方法，虽然这个示意方法是没有传入参数的
9.      * 但实际是可以传入参数的，根据具体需要来选择是否传递参数
10.      */
11.     public abstract void handleRequest();
12.     /**
13.      * 取值方法
14.      */
15.     public Handler getSuccessor() {
16.         return successor;
17.     }
18.     /**
19.      * 赋值方法，设置后继的责任对象
20.      */
21.     public void setSuccessor(Handler successor) {
22.         this.successor = successor;
23.     }
24.     
25. }

具体处理者角色

1. public class ConcreteHandler extends Handler {
2.     /**
3.      * 处理方法，调用此方法处理请求
4.      */
5.     @Override
6.     public void handleRequest() {
7.         /**
8.          * 判断是否有后继的责任对象
9.          * 如果有，就转发请求给后继的责任对象
10.          * 如果没有，则处理请求
11.          */
12.         if(getSuccessor() != null)
13.         { 
14.             System.out.println("放过请求");
15.             getSuccessor().handleRequest(); 
16.         }else
17.         { 
18.             System.out.println("处理请求");
19.         }
20.     }
21.  
22. }

客户端类

1. public class Client {
2.  
3.     public static void main(String[] args) {
4.         //组装责任链
5.         Handler handler1 = new ConcreteHandler();
6.         Handler handler2 = new ConcreteHandler();
7.         handler1.setSuccessor(handler2);
8.         //提交请求
9.         handler1.handleRequest();
10.     }
11.  
12. }

可以看出，客户端创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。

　　由于本示例的传递逻辑非常简单：只要有下家，就传给下家处理；如果没有下家，就自行处理。因此，第一个处理者对象接到请求后，会将请求传递给第二个处理者对象。由于第二个处理者对象没有下家，于是自行处理请求。活动时序图如下所示。

使用场景

　　来考虑这样一个功能:申请聚餐费用的管理。

　　很多公司都是这样的福利，就是项目组或者是部门可以向公司申请一些聚餐费用，用于组织项目组成员或者是部门成员进行聚餐活动。

　　申请聚餐费用的大致流程一般是：由申请人先填写申请单，然后交给领导审批，如果申请批准下来，领导会通知申请人审批通过，然后申请人去财务领取费用，如果没有批准下来，领导会通知申请人审批未通过，此事也就此作罢。

　　不同级别的领导，对于审批的额度是不一样的，比如，项目经理只能审批500元以内的申请；部门经理能审批1000元以内的申请；而总经理可以审核任意额度的申请。

　　也就是说，当某人提出聚餐费用申请的请求后，该请求会经由项目经理、部门经理、总经理之中的某一位领导来进行相应的处理，但是提出申请的人并不知道最终会由谁来处理他的请求，一般申请人是把自己的申请提交给项目经理，或许最后是由总经理来处理他的请求。

　　可以使用责任链模式来实现上述功能：当某人提出聚餐费用申请的请求后，该请求会在 项目经理—〉部门经理—〉总经理 这样一条领导处理链上进行传递，发出请求的人并不知道谁会来处理他的请求，每个领导会根据自己的职责范围，来判断是处理请求还是把请求交给更高级别的领导，只要有领导处理了，传递就结束了。

　　需要把每位领导的处理独立出来，实现成单独的职责处理对象，然后为它们提供一个公共的、抽象的父职责对象，这样就可以在客户端来动态地组合职责链，实现不同的功能要求了。

源代码

　　抽象处理者角色类

1. public abstract class Handler {
2.     /**
3.      * 持有下一个处理请求的对象
4.      */
5.     protected Handler successor = null;
6.     /**
7.      * 取值方法
8.      */
9.     public Handler getSuccessor() {
10.         return successor;
11.     }
12.     /**
13.      * 设置下一个处理请求的对象
14.      */
15.     public void setSuccessor(Handler successor) {
16.         this.successor = successor;
17.     }
18.     /**
19.      * 处理聚餐费用的申请
20.      * @param user 申请人
21.      * @param fee 申请的钱数
22.      * @return 成功或失败的具体通知
23.      */
24.     public abstract String handleFeeRequest(String user , double fee);
25. }

具体处理者角色

1. public class ProjectManager extends Handler {
2.  
3.     @Override
4.     public String handleFeeRequest(String user, double fee) {
5.         
6.         String str = "";
7.         //项目经理权限比较小，只能在500以内
8.         if(fee < 500)
9.         {
10.             //为了测试，简单点，只同意张三的请求
11.             if("张三".equals(user))
12.             {
13.                 str = "成功：项目经理同意【" + user + "】的聚餐费用，金额为" + fee + "元"; 
14.             }else
15.             {
16.                 //其他人一律不同意
17.                 str = "失败：项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
18.             }
19.         }else
20.         {
21.             //超过500，继续传递给级别更高的人处理
22.             if(getSuccessor() != null)
23.             {
24.                 return getSuccessor().handleFeeRequest(user, fee);
25.             }
26.         }
27.         return str;
28.     }
29.  
30. }

1. public class ProjectManager extends Handler {
2.  
3.     @Override
4.     public String handleFeeRequest(String user, double fee) {
5.         
6.         String str = "";
7.         //项目经理权限比较小，只能在500以内
8.         if(fee < 500)
9.         {
10.             //为了测试，简单点，只同意张三的请求
11.             if("张三".equals(user))
12.             {
13.                 str = "成功：项目经理同意【" + user + "】的聚餐费用，金额为" + fee + "元"; 
14.             }else
15.             {
16.                 //其他人一律不同意
17.                 str = "失败：项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
18.             }
19.         }else
20.         {
21.             //超过500，继续传递给级别更高的人处理
22.             if(getSuccessor() != null)
23.             {
24.                 return getSuccessor().handleFeeRequest(user, fee);
25.             }
26.         }
27.         return str;
28.     }
29.  
30. }

1. public class DeptManager extends Handler {
2.  
3.     @Override
4.     public String handleFeeRequest(String user, double fee) {
5.         
6.         String str = "";
7.         //部门经理的权限只能在1000以内
8.         if(fee < 1000)
9.         {
10.             //为了测试，简单点，只同意张三的请求
11.             if("张三".equals(user))
12.             {
13.                 str = "成功：部门经理同意【" + user + "】的聚餐费用，金额为" + fee + "元"; 
14.             }else
15.             {
16.                 //其他人一律不同意
17.                 str = "失败：部门经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
18.             }
19.         }else
20.         {
21.             //超过1000，继续传递给级别更高的人处理
22.             if(getSuccessor() != null)
23.             {
24.                 return getSuccessor().handleFeeRequest(user, fee);
25.             }
26.         }
27.         return str;
28.     }
29.  
30. }

1. public class GeneralManager extends Handler {
2.  
3.     @Override
4.     public String handleFeeRequest(String user, double fee) {
5.         
6.         String str = "";
7.         //总经理的权限很大，只要请求到了这里，他都可以处理
8.         if(fee >= 1000)
9.         {
10.             //为了测试，简单点，只同意张三的请求
11.             if("张三".equals(user))
12.             {
13.                 str = "成功：总经理同意【" + user + "】的聚餐费用，金额为" + fee + "元"; 
14.             }else
15.             {
16.                 //其他人一律不同意
17.                 str = "失败：总经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
18.             }
19.         }else
20.         {
21.             //如果还有后继的处理对象，继续传递
22.             if(getSuccessor() != null)
23.             {
24.                 return getSuccessor().handleFeeRequest(user, fee);
25.             }
26.         }
27.         return str;
28.     }
29.  
30. }

客户端类
 

1. public class Client {
2.  
3.     public static void main(String[] args) {
4.         //先要组装责任链
5.         Handler h1 = new GeneralManager();
6.         Handler h2 = new DeptManager();
7.         Handler h3 = new ProjectManager();
8.         h3.setSuccessor(h2);
9.         h2.setSuccessor(h1);
10.         
11.         //开始测试
12.         String test1 = h3.handleFeeRequest("张三", 300);
13.         System.out.println("test1 = " + test1);
14.         String test2 = h3.handleFeeRequest("李四", 300);
15.         System.out.println("test2 = " + test2);
16.         System.out.println("---------------------------------------");
17.         
18.         String test3 = h3.handleFeeRequest("张三", 700);
19.         System.out.println("test3 = " + test3);
20.         String test4 = h3.handleFeeRequest("李四", 700);
21.         System.out.println("test4 = " + test4);
22.         System.out.println("---------------------------------------");
23.         
24.         String test5 = h3.handleFeeRequest("张三", 1500);
25.         System.out.println("test5 = " + test5);
26.         String test6 = h3.handleFeeRequest("李四", 1500);
27.         System.out.println("test6 = " + test6);
28.     }
29.  
30. }

纯的与不纯的责任链模式

　　一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个：一是承担责任，而是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又 把责任向下传的情况。

　　在一个纯的责任链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的责任链模式里面，一个请求可以最终不被任何接收端对象所接收。

　　纯的责任链模式的实际例子很难找到，一般看到的例子均是不纯的责任链模式的实现。有些人认为不纯的责任链根本不是责任链模式，这也许是有道理的。但是在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。

责任链模式在Tomcat中的应用

　过对Tomcat8.5.5版本的源码进行学习，发现Tomcat中有2个地方用到了责任链模式，一个是管道中的阀门，另一个是过滤器链中的过滤器。下面我们分别来看一下这两个责任链模式具体是如何使用的。
Filter接口如下所示：

public interface Filter { public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain);
} 

Filter接口是所有具体过滤器必须实现的接口，该接口有一个核心的方法doFilter，方法对Request和Response进行处理，注意第三个参数类型为FilterChain，传入该参数的目的是为了责任能够传递到下一个过滤器。 
具体Filter如下所示：
public class MyFilter implements Filter{ @Override public void doFilter(ServletRequest request, ServletResponse response,

 FilterChain chain) { //处理request和response //... chain.doFilter(request,response);
    }
}

首先根据需求对request和response进行处理，最后需要调用过滤器链中的doFilter方法以便责任能够传递到下一个过滤器。chain.doFilter(request,response)，注意这个doFilter是FilterChain中的doFilter与Filter中的doFilter没有任何关系，名字虽然相同，但是参数是不一样的。FilterChain中的doFilter只有Request和Response两个参数，其实更好的命名方式应该是chain.doNextFilter(resquest,response)

那么，FilterChain是什么样的呢？我们上面已经看到了FilterChain的用法，也知道了FilterChain在调用doFilter(request,response)的时候需要有能力将任务传递到下一个Filter,因此我们可以推断，FilterChain中需要保存所有的Filter。在Tomcat的实现中，正是在FilterChain中用一个数组保存了所有的Filter,这不禁让我想起了java.util.ArrayList的实现。 
在Tomcat中FilterChain也是一个接口，如下所示：

public interface FilterChain { public void doFilter(ServletRequest request, ServletResponse response);
}

而ApplicationFilterChain实现了FilterChain,其核心代码如下所示：
 

1. public void doFilter(ServletRequest request, ServletResponse response)
2.         throws IOException, ServletException {
3.  
4.         if( Globals.IS_SECURITY_ENABLED ) {
5.             final ServletRequest req = request;
6.             final ServletResponse res = response;
7.             try {
8.                 java.security.AccessController.doPrivileged(
9.                     new java.security.PrivilegedExceptionAction<Void>() {
10.                         @Override
11.                         public Void run() 
12.                             throws ServletException, IOException {
13.                             internalDoFilter(req,res);
14.                             return null;
15.                         }
16.                     }
17.                 );
18.             } catch( PrivilegedActionException pe) {
19.                 Exception e = pe.getException();
20.                 if (e instanceof ServletException)
21.                     throw (ServletException) e;
22.                 else if (e instanceof IOException)
23.                     throw (IOException) e;
24.                 else if (e instanceof RuntimeException)
25.                     throw (RuntimeException) e;
26.                 else
27.                     throw new ServletException(e.getMessage(), e);
28.             }
29.         } else {
30.             internalDoFilter(request,response);
31.         }
32.     }
33.  
34.     private void internalDoFilter(ServletRequest request, 
35.                                   ServletResponse response)
36.         throws IOException, ServletException {
37.  
38.         // Call the next filter if there is one
39.         if (pos < n) {
40. //在链执行过程中，当pos
41.             ApplicationFilterConfig filterConfig = filters[pos++];
42.             Filter filter = null;
43.             try {
44.                 filter = filterConfig.getFilter();
45.                 support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
46.                                           filter, request, response);
47.                 
48.                 if (request.isAsyncSupported() && "false".equalsIgnoreCase(
49.                         filterConfig.getFilterDef().getAsyncSupported())) {
50.                     request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
51.                             Boolean.FALSE);
52.                 }
53.                 if( Globals.IS_SECURITY_ENABLED ) {
54.                     final ServletRequest req = request;
55.                     final ServletResponse res = response;
56.                     Principal principal = 
57.                         ((HttpServletRequest) req).getUserPrincipal();
58.  
59.                     Object[] args = new Object[]{req, res, this};
60.                     SecurityUtil.doAsPrivilege
61.                         ("doFilter", filter, classType, args, principal);
62.                     
63.                 } else { 
64.                     filter.doFilter(request, response, this);
65.                 }
66.  
67.                 support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
68.                                           filter, request, response);
69.             } catch (IOException e) {
70.                 if (filter != null)
71.                     support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
72.                                               filter, request, response, e);
73.                 throw e;
74.             } catch (ServletException e) {
75.                 if (filter != null)
76.                     support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
77.                                               filter, request, response, e);
78.                 throw e;
79.             } catch (RuntimeException e) {
80.                 if (filter != null)
81.                     support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
82.                                               filter, request, response, e);
83.                 throw e;
84.             } catch (Throwable e) {
85.                 e = ExceptionUtils.unwrapInvocationTargetException(e);
86.                 ExceptionUtils.handleThrowable(e);
87.                 if (filter != null)
88.                     support.fireInstanceEvent(InstanceEvent.AFTER_FILTER_EVENT,
89.                                               filter, request, response, e);
90.                 throw new ServletException
91.                   (sm.getString("filterChain.filter"), e);
92.             }
93.             return;
94.         }
95.  
96.         // We fell off the end of the chain -- call the servlet instance
97.         try {
98.             if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
99.                 lastServicedRequest.set(request);
100.                 lastServicedResponse.set(response);
101.             }
102.  
103.             support.fireInstanceEvent(InstanceEvent.BEFORE_SERVICE_EVENT,
104.                                       servlet, request, response);
105.             if (request.isAsyncSupported()
106.                     && !support.getWrapper().isAsyncSupported()) {
107.                 request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
108.                         Boolean.FALSE);
109.             }
110.             // Use potentially wrapped request from this point
111.             if ((request instanceof HttpServletRequest) &&
112.                 (response instanceof HttpServletResponse)) {
113.                     
114.                 if( Globals.IS_SECURITY_ENABLED ) {
115.                     final ServletRequest req = request;
116.                     final ServletResponse res = response;
117.                     Principal principal = 
118.                         ((HttpServletRequest) req).getUserPrincipal();
119.                     Object[] args = new Object[]{req, res};
120.                     SecurityUtil.doAsPrivilege("service",
121.                                                servlet,
122.                                                classTypeUsedInService, 
123.                                                args,
124.                                                principal); 
125.                 } else { 
126.                     servlet.service(request, response);
127.                 }
128.             } else {
129.                 servlet.service(request, response);
130.             }
131.             support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
132.                                       servlet, request, response);
133.         } catch (IOException e) {
134.             support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
135.                                       servlet, request, response, e);
136.             throw e;
137.         } catch (ServletException e) {
138.             support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
139.                                       servlet, request, response, e);
140.             throw e;
141.         } catch (RuntimeException e) {
142.             support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
143.                                       servlet, request, response, e);
144.             throw e;
145.         } catch (Throwable e) {
146.             ExceptionUtils.handleThrowable(e);
147.             support.fireInstanceEvent(InstanceEvent.AFTER_SERVICE_EVENT,
148.                                       servlet, request, response, e);
149.             throw new ServletException
150.               (sm.getString("filterChain.servlet"), e);
151.         } finally {
152.             if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
153.                 lastServicedRequest.set(null);
154.                 lastServicedResponse.set(null);
155.             }
156.         }
157.  
158.     }

可以看出在FilterChain的实现中确实是用数组来保存所有的过滤器，但是并不是直接保存的Filter类型，而是保存的FilterConfig类型，可以把FilterConfig当做Filter的包装类，我们可以通过filterConfig.getFilter()拿到Filter实例。在internalDoFilter方法中我们看到了FilterChain是如何实现责任的传递的，通过pos和n这两个变量来判断有没有传递到过滤器链的最后面，如果没有到最后，则取出当前过滤器并调用filter.doFilter的方法，在前面MyFilter的实现当中，它的doFilter方法在最后又调用了chain.doFilter(),从而保证了过滤器链能够将责任传递到下一个过滤器中。pos和n这两个变量的作用又让我联想到了ArrayList中的迭代器的实现。

客户端代码如下：
 

1. public class Client{
2.     public static void main(String[] args) {
3.         Request request = new Request();
4.         Response response = new Response();
5.         Filter filter1 = new MyFilter1();
6.         Filter filter2 = new MyFilter2();
7.         Filter filter3 = new MyFilter3();
8.         FilterChain chain = new ApplicationFilterChain();
9.         ApplicationFilterConfig filterConfig1 = new ApplicationFilterConfig(filter1);
10.         ApplicationFilterConfig filterConfig2 = new ApplicationFilterConfig(filter2);
11.         ApplicationFilterConfig filterConfig3 = new ApplicationFilterConfig(filter3);
12.         chain.addFilter(filterConfig1);
13.         chain.addFilter(filterConfig2);
14.         chain.addFilter(filterConfig3);
15.         chain.doFilter(request, response);
16.     }
17. }

以下是Filter接口doFilter定义如下
 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)

过滤器链里面的filter在调用dofilter完成后，会继续调用chain.doFilter(request,response)方法，而这个chain其实就是applicationfilterchain,所以调用过程又回到了上面调用dofilter和调用internalDoFilter方法，这样执行直到里面的过滤器全部执行

当filte都调用完成后，它就会初始化相应的servlet