设计模式初探-责任链模式

责任链模式(CHAIN OF RESPONSIBILITY)，通过将多个对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它，属于对象行为型模式。责任链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。JavaScript的事件处理，工作流系统中公文的多级审批，Web开发中的过滤器和拦截器都可以采用责任链模式实现。

一、使用场景

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求需要等到运行时刻再确定。
2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3、可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序。 

二、UML图

三、Java实现

[java]  view plain  copy

1. package study.patterns.chainofresponsibility;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. /** 
6.  * 对于实现责任链的访问处理顺序问题，该问题的解决使用的是递归的思想，从而使先调用的结点在处理返回结果时其调用过滤器的顺序是相反的。 
7.  * 这种解决方案在Struts和其他框架中实现过滤器和拦截器使用的较为普遍，并且十分巧妙。 
8.  * @author qbg 
9.  * 此处通过实现Web中经常采用的过滤器来演示责任链模式的原理和用法。 
10.  */  
11. public class ChainOfResponsibilityPattern {  
12.     public static void main(String[] args) {  
13.         String message = "敏感词汇，重庆，<script> 躲猫猫 :)";    
14.         Request request = new Request();    
15.         request.setRequestStr(message);    
16.         Response response = new Response();    
17.         response.setResponseStr("response");    
18.         FilterChain fc = new FilterChain();    
19.         fc.addFilter(new HTMLFilter()).addFilter(new SesitiveFilter());    
20.    
21.         FilterChain fc2 = new FilterChain();    
22.         fc2.addFilter(new FaceFilter());    
23.         fc.addFilter(fc2);//由于FilterChain也实现Filter接口，所以可以将一个FilterChain加入到另一个FilterChain中   
24.         fc.doFilter(request, response,fc);    
25.         System.out.println("request = " + request.getRequestStr());    
26.         System.out.println("response = " + response.getResponseStr());    
27.     }  
28. }  
29. /** 
30.  * 封装请求  
31.  */  
32. class Request {    
33.     String requestStr;    
34.    
35.     public String getRequestStr() {    
36.         return requestStr;    
37.     }    
38.    
39.     public void setRequestStr(String requestStr) {    
40.         this.requestStr = requestStr;    
41.     }    
42. }    
43. /** 
44.  * 响应：封装请求经过责任链后的处理结果  
45.  */  
46. class Response {    
47.     String responseStr;    
48.    
49.     public String getResponseStr() {    
50.         return responseStr;    
51.     }    
52.    
53.     public void setResponseStr(String responseStr) {    
54.         this.responseStr = responseStr;    
55.     }    
56. }    
57. /** 
58.  * 过滤器接口  
59.  */  
60. interface Filter {    
61.     public void doFilter(Request request, Response response,FilterChain chain);    
62.    
63. }   
64. /** 
65.  * 过滤器链 
66.  */  
67. class FilterChain implements Filter {    
68.     List<Filter> filters = new ArrayList<Filter>();//存放所有过滤器集合    
69.     int index = 0; //当前过滤器索引，用于判断过滤器链是否执行完毕  
70.    
71.     public FilterChain addFilter(Filter f) {    
72.         this.filters.add(f);    
73.         return this;    
74.     }    
75.    
76.     @Override   
77.     public void doFilter(Request request, Response response, FilterChain chain) {    
78.         if (index == filters.size())    
79.             return;    
80.         Filter f = filters.get(index);    
81.         index++;    
82.         f.doFilter(request, response, chain);    
83.     }    
84. }   
85. /**   
86.  * 过滤HTML中的脚本元素   
87.  *   
88.  */   
89. class HTMLFilter implements Filter {    
90.    
91.     @Override   
92.     public void doFilter(Request request, Response response,FilterChain chain) {    
93.         request.requestStr = request.getRequestStr().replace("<", "[")    
94.                 .replace(">", "] --------HTMLFilter");    
95.         chain.doFilter(request, response, chain);    
96.         response.responseStr += "--------HTMLFilter";    
97.             
98.     }    
99. }   
100. /** 
101.  * 过滤敏感词 
102.  */  
103. class SesitiveFilter implements Filter {    
104.        
105.     @Override   
106.     public void doFilter(Request request, Response response, FilterChain chain) {    
107.         request.requestStr = request.getRequestStr().replace("敏感", "  ")    
108.                 .replace("猫猫", "haha------SesitiveFilter");    
109.         chain.doFilter(request, response, chain);    
110.         response.responseStr += "------SesitiveFilter";    
111.    
112.     }    
113. }  
114. /** 
115.  * 过滤表情符  
116.  */  
117. class FaceFilter implements Filter {    
118.     @Override   
119.     public void doFilter(Request request, Response response, FilterChain chain) {    
120.         request.requestStr = request.getRequestStr().replace(":)",    
121.                 "^V^-------FaceFilter");    
122.         chain.doFilter(request, response, chain);    
123.         response.responseStr += "-------FaceFilter";    
124.    
125.     }    
126. }    

[plain]  view plain  copy

1. request =   词汇，重庆，[script] --------HTMLFilter 躲haha------SesitiveFilter ^V^-------FaceFilter  
2. response = response-------FaceFilter------SesitiveFilter--------HTMLFilter  

四、模式优缺点

优点：

1、降低耦合度。职责链模式将请求处理细节(请求由哪些对象处理，怎样处理)跟客户端代码隔离开来，这些细节对客户端是透明的，客户端只需将相应的职责添加到链中即可，具体的处理过程交给责任链，降低了系统的耦合度。

2、增强了给对象指派职责的灵活性。可以通过在运行时对职责链进行动态的增加或修改来改变处理一个请求的职责，职责链的维护是客户端负责的，所以增加或修改责任链不影响类库代码，非常灵活。

缺点：

1、不保证请求被接受。由于责任链中的每个对象只处理自己感兴趣的请求，对于请求是否处理过并没有感知，这样容易导致请求没有对应的处理者。当一个请求的责任链没有正确配置时也会导致该请求得不到处理。

2、由于责任链模式请求处理的不确定性，所以加大了程序调试的难度。