责任链模式

 

今天学习了下责任链模式，对责任链模式有了一个初步的了解，这个模式有些复杂

 

比如有这样一种情况：有三个经理，A是负责人事的，B负责财务，C负责销售。他们都能对自己所管辖的领域里大大小小的事情进行处理。但是有一些新入职的职员根本不认识他俩，有的时候一个人事部的人跑去财务部领导那里报告情况，这个时候B就要把请求指引到A那里去，也有的时候B也不知道要找谁，就把请求传递给C，让C处理，C当然也没有权限处理，但是它知道要给A,于是就把请求给了A。

 

这样一层一层的将命令下调，直到找到合适的处理者的行为就是责任链模式。每一个经理都有自己的处理权限，而每一个职员终究只用找到一个经理，但最终是能找到合适的。

 

责任链模式的定义：使得多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该对象，直到所有的对象处理完为止。

 

每一个处理者都有固定的权限，和他的下任处理者。

抽象处理者类

Java代码  

1. package com.gengu.责任链;   
2.   
3.   
4. /**抽象处理者*/  
5. public abstract class Handler {   
6.   
7.     //可以处理的级别   
8.     private int level;   
9.     //下一个处理者   
10.     private Handler nextHandler;   
11.        
12.     /**  
13.      * 每个处理者都必须得请求作出一个响应  
14.      * 返回一个值 或者打印一条数据  
15.     */  
16.     public Handler(Handler _nextHandler){   
17.         this.nextHandler = _nextHandler;   
18.     }   
19.     public Handler(int level){   
20.         this.level = level;   
21.     }   
22.     public final void handleMessage(Roler roler){   
23.         //如果权限够  则作出响应   
24.         if(this.level == roler.level){   
25.             this.request();   
26.             //如果有后续的角色 就把请求往下送   
27.         }else if(this.nextHandler != null){   
28.             this.nextHandler.handleMessage(roler);   
29.         }else {   
30.             System.out.println("对不起没有可以处理的角色");   
31.         }          
32.     }   
33.        
34.     //对请求作出处理   
35.     public abstract void request();   
36.        
37.     public void setNextHandler(Handler nextHandler) {   
38.         this.nextHandler = nextHandler;   
39.     }   
40. }  

 具体处理者

Java代码  

1. package com.gengu.责任链;   
2.   
3. /**抽象处理者*/  
4. public class HandlerA extends Handler{   
5.   
6.     //要设置自己的处理级别   
7.     public HandlerA(){   
8.         super(1);   
9.     }   
10.     @Override  
11.     public void request() {   
12.         System.out.println("我是处理者A,我的处理权限是1,我有权利处理");   
13.     };   
14. }   
15.   
16. package com.gengu.责任链;   
17. /**抽象处理者*/  
18. public class HandlerB extends Handler{   
19.   
20.     //要设置自己的处理级别   
21.     public HandlerB(){   
22.         super(2);   
23.     }   
24.     @Override  
25.     public void request() {   
26.         System.out.println("我是处理者B,我的处理权限是2,我有权利处理");   
27.     };   
28. }   
29.   
30. ……  

 角色抽象类

Java代码  

1. package com.gengu.责任链;   
2.   
3. /**  
4.  * 角色抽象类  
5.  * */  
6. public abstract class Roler {   
7.        
8.     protected int level;   
9.     public Roler(int level){   
10.         this . level = level;   
11.     }   
12.     public void doSome(){   
13.         System.out.println("我是角色，我的级别是"+level+"我得做些什么");   
14.     }   
15.   
16. }  

 具体角色类

Java代码  

1. package com.gengu.责任链;   
2.   
3. /**  
4.  * 角色抽象类  
5.  * */  
6. public class RolerA extends Roler{   
7.        
8.     public RolerA(){   
9.         super(1);   
10.     }   
11. }   
12.   
13. package com.gengu.责任链;   
14.   
15. /**  
16.  * 角色抽象类  
17.  * */  
18. public class RolerB extends Roler{   
19.        
20.     public RolerB(){   
21.         super(2);   
22.     }   
23. }  

 测试类

Java代码  

1. package com.gengu.责任链;   
2.   
3. public class Client {   
4.   
5.     public static void main(String[] args) {   
6.         Handler handlerA = new HandlerA();   
7.         Handler handlerB = new HandlerB();   
8.         handlerA.setNextHandler(handlerB);   
9.         Roler rolerB = new RolerB();   
10.         handlerA.handleMessage(rolerB);   
11.            
12.     }   
13. }  

 

责任链模式的优点是，能将请求和处理分开请求者不用直到是谁处理的，处理者可以不用直到请求的全貌，两者解耦。但它的缺点是性能问题很大，每一个请求都要从链头遍历到链尾。