JAVA设计模式十一：--Chain of Responsibility(职责链模式)

职责链模式：
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的藕合关系。将这个对象连成一条链
，并沿着这条链传递该请求，直到有一个对象处理它为止。


 1.当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它。


 2.接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简
   化对象的相互连接，它们仅需保持一个指向其后续者的引用，而不需保持它所有的候选接受者的引用。
   
 3.可随时地增加或修改处理一个请求的结构。增加了给对象指派职责的灵活性。
 

 4.需事先考虑全面，一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。

如图：

举例如下：

[java]  view plain copy print ?

1. package design.chainofresponsibility;  
2.   
3.   
4.   
5. /** 
6.  * 文件名称：design.chainofresponsibility.AbstractHandler.java 
7.  * 创建人：Fei Wong 
8.  * 创建时间： 2012-06-21 
9.  * 电子邮箱：feiwong8@126.com 
10.  * 说明：抽象处理者类 
11.  * */  
12.   
13. public abstract class AbstractHandler {  
14.       
15.     /** 
16.      * 指向下一个处理对象  
17.      * */  
18.     private AbstractHandler nextHandler ;  
19.     /** 
20.      * 处理对象 
21.      * */  
22.     protected Object value ;   
23.     /** 
24.      * 调用的方法，不能重写 
25.      * */  
26.     public final String handleRequest(Object value){  
27.           
28.         if(value == null){  
29.             return null ;   
30.         }  
31.           
32.         this.value = value ;   
33.         /** 
34.          * 如果满足要求，就直接返回 
35.          * */  
36.         if(isInstanceof()){  
37.             return this.handle() ;  
38.         }  
39.           
40.         if(this.nextHandler != null){  
41.             /** 
42.              * 如果步满足就移想下一个目标处理该对象 
43.              * */  
44.             return this.nextHandler.handleRequest( value ) ;    
45.         }  
46.         /** 
47.          * 如果没有满足要求的 直接返回 null  
48.          * */  
49.         return null ;   
50.     }  
51.     /** 
52.      *处理该对象的方法 
53.      * */  
54.     public abstract String handle() ;   
55.     /** 
56.      * 判断是否符合要求的方法 
57.      * */  
58.     public abstract boolean isInstanceof() ;   
59.     /** 
60.      * 设置下一个负责人  
61.      * */  
62.     public final void setNextHandler(AbstractHandler nextHandler) {  
63.         this.nextHandler = nextHandler;  
64.     }  
65. }  
66.   
67.   
68.   
69.   
70. package design.chainofresponsibility;  
71.   
72. import java.util.Date;  
73.   
74.   
75. /** 
76.  * 文件名称：design.chainofresponsibility.DateToStringHandler.java 
77.  * 创建人：Fei Wong 
78.  * 创建时间： 2012-06-21 
79.  * 电子邮箱：feiwong8@126.com 
80.  * 说明：日期转String的处理类 
81.  * */  
82. public class DateToStringHandler extends AbstractHandler{  
83.   
84.     @Override  
85.     public String handle() {  
86.           
87.         java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;  
88.         return sdf.format( value  ) ;    
89.     }  
90.   
91.     @Override  
92.     public boolean isInstanceof() {  
93.          if (value instanceof Date) {  
94.             return true ;  
95.         }  
96.         return false;  
97.     }  
98.   
99. }  
100.   
101.   
102.   
103.   
104. package design.chainofresponsibility;  
105.   
106.   
107. /** 
108.  * 文件名称：design.chainofresponsibility.IntegerToStringHandler.java 
109.  * 创建人：Fei Wong 
110.  * 创建时间： 2012-06-21 
111.  * 电子邮箱：feiwong8@126.com 
112.  * 说明：书写Integer转 String的类  
113.  * */  
114.   
115. public class IntegerToStringHandler extends AbstractHandler{  
116.       
117.     @Override  
118.     public String handle() {  
119.         Integer integer = (Integer)value ;  
120.         return Integer.toString( integer ) ;   
121.     }  
122.       
123.     @Override  
124.     public boolean isInstanceof() {  
125.         if (value instanceof Integer) {  
126.             return true ;   
127.         }  
128.         return false ;   
129.     }  
130. }  
131.   
132.   
133.   
134.   
135. package design.chainofresponsibility;  
136.   
137. public class StringToStringHandler extends AbstractHandler {  
138.   
139.     @Override  
140.     public String handle() {  
141.         return value.toString() ;  
142.     }  
143.   
144.     @Override  
145.     public boolean isInstanceof() {  
146.         return (value instanceof String);  
147.     }  
148.   
149. }  
150.   
151.   
152.   
153.   
154. package design.chainofresponsibility;  
155.   
156.   
157. /** 
158.  * 文件名称：design.chainofresponsibility.Main.java 
159.  * 创建人：Fei Wong 
160.  * 创建时间： 2012-06-21 
161.  * 电子邮箱：feiwong8@126.com 
162.  * 说明：测试处理 
163.  * */  
164. public class Main {  
165.      public static void main(String[] args) {  
166.         AbstractHandler handler = new IntegerToStringHandler() ;  
167.           
168.         AbstractHandler handler1 = new DateToStringHandler() ;   
169.           
170.         AbstractHandler handler2 = new StringToStringHandler() ;  
171.           
172.         handler.setNextHandler( handler1 ) ;    
173.           
174.         handler1.setNextHandler( handler2 ) ;    
175.           
176.         System.out.println( handler.handleRequest( 1 )  ) ;   
177.     }  
178. }  

这里模拟了不同类型额对象转换成为String字符串，犹豫每种对象转换成为字符串的方法不同，责任也就不同， 这里分开负责自己的事情，如果是数据自己的职责，

就自己做了，不属于自己的职责就让给下一个去做。

转载处：http://blog.youkuaiyun.com/hfmbook/article/details/7683187