JAVA之责任链模式
原文地址：http://itzyx.com/index.php/java_zrl/
在阎宏博士的《JAVA与模式》一书中开头是这样描述责任链（Chain of Responsibility）模式的：
责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
从击鼓传花谈起
击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒。
比如说，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政传给贾宝玉，又贾宝玉传给贾环，由贾环传回给贾母，如此往复，如下图所示。当鼓声停止时，手中有花的人就得执行酒令。
击鼓传花便是责任链模式的应用。责任链可能是一条直线、一个环链或者一个树结构的一部分。
屌丝们 如何理解呢
我们将击鼓者看完 AV种子 大家都懂的 ，屌丝一（贾母），屌丝二，屌丝三 等等。。。
屌丝一拿到种子，看后不是自己想要的片，传给了屌丝二，然后继续传递，应用下去
责任链模式的结构
下面使用了一个责任链模式的最简单的实现。
责任链模式涉及到的角色如下所示：
● 抽象处理者(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. }
屌丝怎么写抽象处理者角色
26. public abstract class DiaoSi{
27.
28. /**
29. * 持有后继的责任对象
30. */
31. protected DiaoSi successor;
32. /**
33. * 示意处理请求的方法，虽然这个示意方法是没有传入参数的
34. * 但实际是可以传入参数的，根据具体需要来选择是否传递参数
35. */
36. public abstract void handleAVRequest();
37. /**
38. * 取值方法
39. */
40. public Handler getSuccessor() {
41. return successor;
42. }
43. /**
44. * 赋值方法，设置后继的责任对象
45. */
46. public void setSuccessor(DiaoSi successor) {
47. this.successor = successor;
48. }
49.
50. }
具体处理者角色
1. public class ConcreteHandler extends Handler {
2. /**
3. * 处理方法，调用此方法处理请求
4. */
5. @Override
6. public void handleAVRequest() {
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. }
屌丝怎么写具体处理者角色
23. public class ConcreteDiaoSi extends DiaoSi {
24. /**
25. * 处理方法，调用此方法处理请求
26. */
27. @Override
28. public void handleRequest() {
29. /**
30. * 判断是否有后继的责任对象
31. * 如果有，就转发请求给后继的责任对象
32. * 如果没有，则处理请求
33. */
34. if(getSuccessor() != null)
35. {
36. System.out.println("放过请求");
37. getSuccessor().handleRequest();
38. }else
39. {
40. System.out.println("没有想要的种子，处理请求");
41. }
42. }
43. }
客户端类
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. public class Client {
12.
13. public static void main(String[] args) {
14. //组装责任链
15. DiaoSi diaoSi1 = new ConcreteDiaoSi ();
16. DiaoSi diaoSi2= new ConcreteDiaoSi();
17. diaoSi1.setSuccessor(diaoSi2);
18. //提交请求
19. diaoSi1.handleRequest();
20. }
21.
22. }
23.
可以看出，客户端创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。
由于本示例的传递逻辑非常简单：只要有下家，就传给下家处理；如果没有下家，就自行处理。因此，第一个处理者对象接到请求后，会将请求传递给第二个处理者对象。由于第二个处理者对象没有下家，于是自行处理请求。活动时序图如下所示。
使用场景
来考虑这样一个功能:申请聚餐费用的管理。
很多公司都是这样的福利，就是项目组或者是部门可以向公司申请一些聚餐费用，用于组织项目组成员或者是部门成员进行聚餐活动。
申请聚餐费用的大致流程一般是：由申请人先填写申请单，然后交给领导审批，如果申请批准下来，领导会通知申请人审批通过，然后申请人去财务领取费用，如果没有批准下来，领导会通知申请人审批未通过，此事也就此作罢。
不同级别的领导，对于审批的额度是不一样的，比如，项目经理只能审批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. }
26.
27.
28.
几个屌丝想去夜总会玩一次 由于都是穷挫矮 边准备凑钱一起玩 唉 太邪恶了
于是向小姐说了想法，小姐说这不行，你们一起上，我扛不住，我得向经理问问看多少钱合适，还有多少人我能抗住，经理知道后，这不行，我也不知道多少钱合适，要向有经验的总经理问。
可以使用责任链模式来实现上述功能：当某屌丝提出消费申请的请求后，该请求会在 小姐—〉部门经理—〉总经理 这样一条领导处理链上进行传递，发出请求的人并不知道谁会来处理他的请求，每个领导会根据自己的职责范围，来判断是处理请求还是把请求交给更高级别的领导，只要有领导处理了，传递就结束了。
需要把每位领导的处理独立出来，实现成单独的职责处理对象，然后为它们提供一个公共的、抽象的父职责对象，这样就可以在客户端来动态地组合职责链，实现不同的功能要求了。
29. public abstract class DiaoSi{
30. /**
31. * 持有下一个处理请求的对象
32. */
33. protected DiaoSi successor = null;
34. /**
35. * 取值方法
36. */
37. public DiaoSi getSuccessor() {
38. return successor;
39. }
40. /**
41. * 设置下一个处理请求的对象
42. */
43. public void setSuccessor(Handler successor) {
44. this.successor = successor;
45. }
46. /**
47. * 处理聚餐费用的申请
48. * @param user 申请人
49. * @param fee 申请的钱数
50. * @return 成功或失败的具体通知
51. */
52. public abstract String handlePiaoFeiRequest(String user , double PiaoFei);
}
53. 具体处理者角色
1. public class 小姐 extends 屌丝{
2.
3. @Override
4. public String handlePiaoFeiRequest(String user , double PiaoFei) {
5.
6. String str = "";
7. //小姐权限比较小，只能在500元以内
8. if(fee < 500)
9. {
10. //为了测试，简单点，只同意张三的请求
11. if("小姐1".equals(user))
12. {
13. str = "成功：小姐同意【" + user + "】的piao的费用（写的隐晦点以免被和谐），金额为" + PiaoFei+ "元";
14. }else
15. {
16. //其他人一律不同意
17. str = "失败：小姐不同意【" + user + "】的piao的费用（写的隐晦点以免被和谐），金额为" + PiaoFei+ "元";
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 经理extends DiaoSi{
2.
3. @Override
4. public String handlePiaoFeiRequest(String user , double PiaoFei） {
5.
6. String str = "";
7. //部门经理的权限只能在1000以内
8. if(fee < 1000)
9. {
10. //为了测试，简单点，只同意张三的请求
11. if("经理1".equals(user))
12. {
13. str = "成功：经理同意【" + user + "】的费用，金额为" + PiaoFei+ "元";
14. }else
15. {
16. //其他人一律不同意
17. str = "失败：经理不同意【" + user + "】的费用，金额为" + PiaoFei+ "元";
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. }
31. public class 总经理extends DiaoSi{
32.
33. @Override
34. public String handlePiaoFeiRequest(String user , double PiaoFei） {
35.
36. String str = "";
37. //部门经理的权限只能在1000以内
38. if(fee < 1000)
39. {
40. //为了测试，简单点，只同意张三的请求
41. if("总经理".equals(user))
42. {
43. str = "成功：总经理同意【" + user + "】的费用，金额为" + PiaoFei+ "元";
44. }else
45. {
46. //其他人一律不同意
47. str = "失败：总经理不同意【" + user + "】的聚餐费用，金额为" + PiaoFei+ "元";
48. }
49. }else
50. {
51. //超过1000，继续传递给级别更高的人处理
52. if(getSuccessor() != null)
53. {
54. return getSuccessor().handleFeeRequest(user, fee);
55. }
56. }
57. return str;
58. }
59.
60. }
1. public class 董事长extends DiaoSi{
2.
3. @Override
4. public handlePiaoFeiRequest(String user , double PiaoFei） {
5.
6. String str = "";
7. //总经理的权限很大，只要请求到了这里，他都可以处理
8. if(fee >= 1000)
9. {
10. //为了测试，简单点，只同意张三的请求
11. if("张三".equals(user))
12. {
13. str = "成功：董事长同意【" + user + "】的费用，金额为" + PiaoFei+ "元";
14. }else
15. {
16. //其他人一律不同意
17. str = "失败：董事长不同意【" + user + "】的费用，金额为" + PiaoFei+ "元";
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. DiaoSi h1 = new 董事长();
6. DiaoSi h2 = new 总经理();
7. DiaoSi h3 = new 经理();
8. DiaoSi h4 = new 小姐();
9.
1. h4.setSuccessor(h3);
10. h3.setSuccessor(h2);
11. h2.setSuccessor(h1);
12.
13. //开始测试
14. String test1 = h4.handleFeeRequest("小姐", 300);
15. System.out.println("test1 = " + test1);
16. String test2 = h3.handleFeeRequest("经理", 300);
17. System.out.println("test2 = " + test2);
18. System.out.println("---------------------------------------");
19.
20. String test3 = h3.handleFeeRequest("总经理", 700);
21. System.out.println("test3 = " + test3);
22. String test4 = h3.handleFeeRequest("董事长", 700);
23. System.out.println("test4 = " + test4);
24. System.out.println("---------------------------------------");
25.
26. String test5 = h3.handleFeeRequest("小姐", 1500);
27. System.out.println("test5 = " + test5);
28. String test6 = h3.handleFeeRequest("经理", 1500);
29. System.out.println("test6 = " + test6);
30. }
31.
32. }
运行结果如下所示：
纯的与不纯的责任链模式
一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个：一是承担责任，而是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又 把责任向下传的情况。
在一个纯的责任链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的责任链模式里面，一个请求可以最终不被任何接收端对象所接收。
纯的责任链模式的实际例子很难找到，一般看到的例子均是不纯的责任链模式的实现。有些人认为不纯的责任链根本不是责任链模式，这也许是有道理的。但是在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。
责任链模式在Tomcat中的应用
众所周知Tomcat中的Filter就是使用了责任链模式，创建一个Filter除了要在web.xml文件中做相应配置外，还需要实现javax.servlet.Filter接口。
1. public class TestFilter implements Filter{
2.
3. public void doFilter(ServletRequest request, ServletResponse response,
4. FilterChain chain) throws IOException, ServletException {
5.
6. chain.doFilter(request, response);
7. }
8.
9. public void destroy() {
10. }
11.
12. public void init(FilterConfig filterConfig) throws ServletException {
13. }
14.
15. }
使用DEBUG模式所看到的结果如下
其实在真正执行到TestFilter类之前，会经过很多Tomcat内部的类。顺带提一下其实Tomcat的容器设置也是责任链模式，注意被红色方框所圈中的类，从Engine到Host再到Context一直到Wrapper都是通过一个链传递请求。被绿色方框所圈中的地方有一个名为ApplicationFilterChain的类，ApplicationFilterChain类所扮演的就是抽象处理者角色，而具体处理者角色由各个Filter扮演。
第一个疑问是ApplicationFilterChain将所有的Filter存放在哪里？
答案是保存在ApplicationFilterChain类中的一个ApplicationFilterConfig对象的数组中。
1. public ApplicationFilterChain createFilterChain
2. (ServletRequest request, Wrapper wrapper, Servlet servlet) {
3.
4. // get the dispatcher type
5. DispatcherType dispatcher = null;
6. if (request.getAttribute(DISPATCHER_TYPE_ATTR) != null) {
7. dispatcher = (DispatcherType) request.getAttribute(DISPATCHER_TYPE_ATTR);
8. }
9. String requestPath = null;
10. Object attribute = request.getAttribute(DISPATCHER_REQUEST_PATH_ATTR);
11.
12. if (attribute != null){
13. requestPath = attribute.toString();
14. }
15.
16. // If there is no servlet to execute, return null
17. if (servlet == null)
18. return (null);
19.
20. boolean comet = false;
21.
22. // Create and initialize a filter chain object
23. ApplicationFilterChain filterChain = null;
24. if (request instanceof Request) {
25. Request req = (Request) request;
26. comet = req.isComet();
27. if (Globals.IS_SECURITY_ENABLED) {
28. // Security: Do not recycle
29. filterChain = new ApplicationFilterChain();
30. if (comet) {
31. req.setFilterChain(filterChain);
32. }
33. } else {
34. filterChain = (ApplicationFilterChain) req.getFilterChain();
35. if (filterChain == null) {
36. filterChain = new ApplicationFilterChain();
37. req.setFilterChain(filterChain);
38. }
39. }
40. } else {
41. // Request dispatcher in use
42. filterChain = new ApplicationFilterChain();
43. }
44.
45. filterChain.setServlet(servlet);
46.
47. filterChain.setSupport
48. (((StandardWrapper)wrapper).getInstanceSupport());
49.
50. // Acquire the filter mappings for this Context
51. StandardContext context = (StandardContext) wrapper.getParent();
52. FilterMap filterMaps[] = context.findFilterMaps();
53.
54. // If there are no filter mappings, we are done
55. if ((filterMaps == null) || (filterMaps.length == 0))
56. return (filterChain);
57.
58. // Acquire the information we will need to match filter mappings
59. String servletName = wrapper.getName();
60.
61. // Add the relevant path-mapped filters to this filter chain
62. for (int i = 0; i < filterMaps.length; i++) {
63. if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
64. continue;
65. }
66. if (!matchFiltersURL(filterMaps[i], requestPath))
67. continue;
68. ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
69. context.findFilterConfig(filterMaps[i].getFilterName());
70. if (filterConfig == null) {
71. // FIXME - log configuration problem
72. continue;
73. }
74. boolean isCometFilter = false;
75. if (comet) {
76. try {
77. isCometFilter = filterConfig.getFilter() instanceof CometFilter;
78. } catch (Exception e) {
79. // Note: The try catch is there because getFilter has a lot of
80. // declared exceptions. However, the filter is allocated much
81. // earlier
82. Throwable t = ExceptionUtils.unwrapInvocationTargetException(e);
83. ExceptionUtils.handleThrowable(t);
84. }
85. if (isCometFilter) {
86. filterChain.addFilter(filterConfig);
87. }
88. } else {
89. filterChain.addFilter(filterConfig);
90. }
91. }
92.
93. // Add filters that match on servlet name second
94. for (int i = 0; i < filterMaps.length; i++) {
95. if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
96. continue;
97. }
98. if (!matchFiltersServlet(filterMaps[i], servletName))
99. continue;
100. ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
101. context.findFilterConfig(filterMaps[i].getFilterName());
102. if (filterConfig == null) {
103. // FIXME - log configuration problem
104. continue;
105. }
106. boolean isCometFilter = false;
107. if (comet) {
108. try {
109. isCometFilter = filterConfig.getFilter() instanceof CometFilter;
110. } catch (Exception e) {
111. // Note: The try catch is there because getFilter has a lot of
112. // declared exceptions. However, the filter is allocated much
113. // earlier
114. }
115. if (isCometFilter) {
116. filterChain.addFilter(filterConfig);
117. }
118. } else {
119. filterChain.addFilter(filterConfig);
120. }
121. }
122.
123. // Return the completed filter chain
124. return (filterChain);
125.
126. }
可以将如上代码分为两段，51行之前为第一段，51行之后为第二段。
第一段的主要目的是创建ApplicationFilterChain对象以及一些参数设置。
第二段的主要目的是从上下文中获取所有Filter信息，之后使用for循环遍历并调用filterChain.addFilter(filterConfig);将filterConfig放入ApplicationFilterChain对象的ApplicationFilterConfig数组中。
那ApplicationFilterFactory类的createFilterChain()方法又是在什么地方被调用的呢？
是在StandardWrapperValue类的invoke()方法中被调用的。
由于invoke()方法较长，所以将很多地方省略。
1. public final void invoke(Request request, Response response)
2. throws IOException, ServletException {
3. ...省略中间代码
4. // Create the filter chain for this request
5. ApplicationFilterFactory factory =
6. ApplicationFilterFactory.getInstance();
7. ApplicationFilterChain filterChain =
8. factory.createFilterChain(request, wrapper, servlet);
9. ...省略中间代码
10. filterChain.doFilter(request.getRequest(), response.getResponse());
11. ...省略中间代码
12. }
那正常的流程应该是这样的：
在StandardWrapperValue类的invoke()方法中调用ApplicationFilterChai类的createFilterChain()方法———>在ApplicationFilterChai类的createFilterChain()方法中调用ApplicationFilterChain类的addFilter()方法———>在ApplicationFilterChain类的addFilter()方法中给ApplicationFilterConfig数组赋值。
根据上面的代码可以看出StandardWrapperValue类的invoke()方法在执行完createFilterChain()方法后，会继续执行ApplicationFilterChain类的doFilter()方法，然后在doFilter()方法中会调用internalDoFilter()方法。
以下是internalDoFilter()方法的部分代码
1. // Call the next filter if there is one
2. if (pos < n) {
3. //拿到下一个Filter，将指针向下移动一位
4. //pos它来标识当前ApplicationFilterChain（当前过滤器链）执行到哪个过滤器
5. ApplicationFilterConfig filterConfig = filters[pos++];
6. Filter filter = null;
7. try {
8. //获取当前指向的Filter的实例
9. filter = filterConfig.getFilter();
10. support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
11. filter, request, response);
12.
13. if (request.isAsyncSupported() && "false".equalsIgnoreCase(
14. filterConfig.getFilterDef().getAsyncSupported())) {
15. request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
16. Boolean.FALSE);
17. }
18. if( Globals.IS_SECURITY_ENABLED ) {
19. final ServletRequest req = request;
20. final ServletResponse res = response;
21. Principal principal =
22. ((HttpServletRequest) req).getUserPrincipal();
23.
24. Object[] args = new Object[]{req, res, this};
25. SecurityUtil.doAsPrivilege
26. ("doFilter", filter, classType, args, principal);
27.
28. } else {
29. //调用Filter的doFilter()方法
30. filter.doFilter(request, response, this);
31. }
这里的filter.doFilter(request, response, this);就是调用我们前面创建的TestFilter中的doFilter()方法。而TestFilter中的doFilter()方法会继续调用chain.doFilter(request, response);方法，而这个chain其实就是ApplicationFilterChain,所以调用过程又回到了上面调用dofilter和调用internalDoFilter方法，这样执行直到里面的过滤器全部执行。
如果定义两个过滤器，则Debug结果如下：
