JAVA中责任链模式

使很多对象都有处理请求的机会，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止责任链模式主要包括以下几个角色

1、处理者：处理者是一个接口，负责规定具体处理者处理用户请求的方法以及具体处理者设置后继处理对象的方法

2、具体处理者：具体处理者是实现处理接口的类的实例，具体处理者通过调用处理接口规定的方法处理用户的请求，既在接到用户的请求后，处理者将调用接口规定的方法，在执行该方法的过程中，如果发现能处理用户的请求，就处理用户的请求。如果发现处理不了就交给下一个处理者进行处理。

例如一个图书检索的程序，根据图书类别将图书分为了N个种类，然后创建若干个种类的对象，每个对象对一个种类进行检索。为了能更好的管理这些对象，可以将这额对象组织成一个责任链，当用户需要鉴定书籍时，系统可以让责任链上的第一个对象来处理用户的请求，这个对象首先检索自己是否能够处理用户的请求，如果能处理就反馈并返回处理内容。如果不能处理则交给下一个处理对象进行处理。

1. package org.zhy.design.demo;  
2.   
3. /** 
4.  * 处理接口 
5.  * @author zhengyi 
6.  * 
7.  */  
8. public interface Handler {  
9.   
10.     //根据书的ID进行检索   
11.     public abstract void Search(int id);  
12.       
13.     //下一个处理者 参数为实现处理接口的实现类   
14.     public abstract void nextHandler(Handler han);  
15. }  

1. package org.zhy.design.demo;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. /** 
7.  * 文学类的书籍检索 
8.  * @author zhengyi 
9.  * 
10.  */  
11. public class WenXue implements Handler{  
12.   
13.     private Handler han;//下一个处理者   
14.     private List<Integer> list;  //模拟文学类书籍的编号   
15.       
16.     public WenXue(){  
17.         list=new ArrayList<Integer>();  
18.         list.add(1);  
19.         list.add(2);  
20.         list.add(3);  
21.         list.add(4);  
22.         list.add(5);  
23.     }  
24.       
25.     @Override  
26.     public void nextHandler(Handler han) {  
27.         this.han=han;  //给下一个处理者赋值   
28.     }  
29.     @Override  
30.     public void Search(int id) {  
31.         if(list.contains(id)){ //检索list中是否存在此ID的书籍，如果存在则打印   
32.             System.out.println("恭喜您，您检索的书籍是文学类的");  
33.         }else{ //如果没有此书籍则交给下一个处理者进行处理   
34.             if(han!=null){  
35.                 han.Search(id);  
36.             }  
37.         }  
38.     }  
39. }  

1. package org.zhy.design.demo;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. /** 
7.  * 计算机类的书籍 
8.  * @author zhengyi 
9.  * 
10.  */  
11. public class JiSuanJi implements Handler {  
12.   
13.     private Handler han;  
14.     private List<Integer> list;  
15.     public JiSuanJi(){  
16.         list=new ArrayList<Integer>();  
17.         list.add(6);  
18.         list.add(7);  
19.         list.add(8);  
20.         list.add(9);  
21.         list.add(10);  
22.     }  
23.     @Override  
24.     public void nextHandler(Handler han) {  
25.         this.han=han;  
26.     }  
27.     @Override  
28.     public void Search(int id) {  
29.         if(list.contains(id)){  
30.             System.out.println("恭喜你，此书记在计算机类");  
31.         }else{  
32.             if(han!=null){  
33.                 han.Search(id);  
34.             }  
35.         }  
36.     }  
37. }  

1. package org.zhy.design.demo;  
2.   
3. public class Appliction {  
4.   
5.     private Handler jisuanji,wenxue;  
6.       
7.     public void createHandler(){  
8.         jisuanji=new JiSuanJi();  
9.         wenxue=new WenXue();  
10.         jisuanji.nextHandler(wenxue);  //指定下一个处理者   
11.     }  
12.       
13.     public void search(int id){  
14.         jisuanji.Search(id);  //第一个处理者进行筛选处理   
15.     }  
16.       
17.       
18.     public static void main(String args) {  
19.         Appliction app=new Appliction();  
20.         app.createHandler();  
21.         app.search(10);  
22.     }  
23. }  

1、在许多对象可以处理用户请求的时候
2、希望用户不必明确处理者的时候，同时向多个处理者发送请求
3、程序希望动态的订制可处理用户请求的集合对象

TAG: JavaJAVAjava