责任链模式

时间：2017-03-01 14:05:21 阅读：197 评论：0 收藏：0 [点我收藏+]

　　责任链（Chain of Responsibility）模式：责任链模式是对象的行为模式。使多个对象都有机会处理请求，从而避免请求的发送者和接受者直接的耦合关系。将这些对象连成一条链，沿着这条链传递该请求，直到有一个对象处理它为止。责任链模式强调的是每一个对象及其对下家的引用来组成一条链，利用这种方式将发送者和接收者解耦，类图如下：

技术分享

　　通过上图可以看出责任链模式有两个角色：

　　抽象处理者（Handler）角色：定义一个请求的接口。如果需要可以定义个一个方法用来设定和返回下家对象的引用。

　　具体处理者（ConcreteHandler）角色：如果可以处理就处理请求，如果不能处理，就把请求传给下家，让下家处理。也就是说它处理自己能处理的请求且可以访问它的下家。

　　抽象处理角色

 1 public abstract class Handler {  
 2   
 3     protected Handler successor;    
 4     public abstract void handlerRequest(String condition);  
 5       
 6       
 7     public Handler getSuccessor() {  
 8         return successor;  
 9     }  
10     public void setSuccessor(Handler successor) {  
11         this.successor = successor;  
12     }     
13       
14 }

　　具体处理角色

 1 public class ConcreteHandler1 extends Handler {  
 2   
 3     @Override  
 4     public void handlerRequest(String condition) {  
 5         // 如果是自己的责任，就自己处理，负责传给下家处理  
 6         if(condition.equals("ConcreteHandler1")){  
 7             System.out.println( "ConcreteHandler1 handled ");  
 8             return ;  
 9         }else{  
10             System.out.println( "ConcreteHandler1 passed ");  
11             getSuccessor().handlerRequest(condition);  
12         }  
13     }  
14   
15 }

 1 public class ConcreteHandler2 extends Handler {  
 2       
 3     @Override  
 4     public void handlerRequest(String condition) {  
 5         // 如果是自己的责任，就自己处理，负责传给下家处理  
 6         if(condition.equals("ConcreteHandler2")){  
 7             System.out.println( "ConcreteHandler2 handled ");  
 8             return ;  
 9         }else{  
10             System.out.println( "ConcreteHandler2 passed ");  
11             getSuccessor().handlerRequest(condition);  
12         }  
13     }  
14   
15 }

 1 public class ConcreteHandlerN extends Handler {  
 2   
 3     /** 
 4      * 这里假设n是链的最后一个节点必须处理掉 
 5      * 在实际情况下，可能出现环，或者是树形， 
 6      * 这里并不一定是最后一个节点。 
 7      *  
 8      */  
 9     @Override  
10     public void handlerRequest(String condition) {  
11   
12         System.out.println( "ConcreteHandlerN handled");  
13           
14     }  
15   
16 }

　　运行代码：

 1 public class Client {  
 2   
 3     public static void main(String[] args) {  
 4       
 5         Handler handler1 = new ConcreteHandler1();  
 6         Handler handler2 = new ConcreteHandler2();  
 7         Handler handlern = new ConcreteHandlerN();  
 8           
 9         //链起来  
10         handler1.setSuccessor(handler2);  
11         handler2.setSuccessor(handlern);  
12           
13         //假设这个请求是ConcreteHandler2的责任  
14         handler1.handlerRequest("ConcreteHandler2");  
15           
16           
17     }  
18   
19 }

　　举这样一个例子，在玩具工厂的生产车间，流水线就是一条责任链，假如一个玩具飞机有外壳装配员，引擎装配员，螺旋桨装配员，模型包装员组成。当这个物件飞机流到谁那里，谁就负责安装他负责的这一部分，这部分安装完成后流到下一个环节，知道所有环境完成。这个是一生成的责任链。还有一个质量检测链，质量检测也分多部，外壳检测，引擎检测，螺旋桨检测，包装检测。当产品留到检测员那里检测自己负责的那一块，如果有问题直接拎出来，如果没问题则传给下一个检测员，直到所有检测完成。这两个都是责任链，但是区别是，生成责任链每个人都会处理，并处理一部分；而质量检测责任链经过判断，要么处理掉，要么不处理流下去。这就是责任链的两种分类，后一种叫做纯的责任链，前一种叫做不纯的责任链，纯的责任链在实际应用中很少存在，常见的为不纯的责任链，上面的模型是模拟纯的责任链来处理的。

责任链模式在现实中使用的很多，常见的就是OA系统中的工作流。在java中的实际应用有Servlet中的过滤器（Filter），Struts2的拦截器（Interceptor）。Struts2本身在Servlet中也是以Filter的形式出现的，所以Struts2的结构图中，也可以明显看出Filter和Interceptor这两条链的存在。

　　可以看出它们每个节点都可以做一些事情，所以不算一个纯的责任链。

　　在上面提到了OA系统，那么我们再模拟一下OA系统中请假审批流程，假如员工直接上司为小组长，小组长直接上司项目经理，项目经理直接上司部门经理，部门经理直接上司总经理。公司规定请假审批如下：

请假时间为t,时间单位day，简写d：

t< 0.5d，小组长审批；

t>=0.5d,t<2,项目经理审批；

t>=2,t<5部门经理审批；

t>=5总经理审批；

审批时序图如下：

　　用代码描述：

 1 public abstract class Handler {  
 2   
 3     protected Handler handler;  
 4   
 5     public abstract boolean approve(double day);  
 6       
 7     public Handler getHandler() {  
 8         return handler;  
 9     }  
10     public void setHandler(Handler handler) {  
11         this.handler = handler;  
12     }  
13       
14 }

　　实现者：

 1 public class GroupLeader extends Handler {  
 2   
 3     @Override  
 4     public boolean approve(double day) {  
 5         if(day<0.5){  
 6             System.out.println("小组长审批通过");  
 7             return true;  
 8         }else {  
 9             System.out.println("小组长传给了他的上司");  
10             return getHandler().approve(day);  
11         }  
12     }  
13   
14   
15 }

 1 public class ProjectManager extends Handler {  
 2   
 3     @Override  
 4     public boolean approve(double day) {  
 5         if(day<2){  
 6             System.out.println("项目经理审批通过");  
 7             return true;  
 8         }else {  
 9             System.out.println("项目经理传给了他的上司");  
10             return getHandler().approve(day);  
11         }  
12     }  
13   
14   
15 }

 1 public class DepartmentManager extends Handler {  
 2   
 3     @Override  
 4     public boolean approve(double day) {  
 5         if(day<5){  
 6             System.out.println("部门经理审批通过");  
 7             return true;  
 8         }else {  
 9             System.out.println("部门经理传给了他的上司");  
10             return getHandler().approve(day);  
11         }  
12     }  
13   
14   
15 }

 1 public class CEO extends Handler {  
 2   
 3     @Override  
 4     public boolean approve(double day) {  
 5             System.out.println("部门经理审批通过");  
 6             return true;  
 7           
 8     }  
 9   
10 }

　　运行代码：

 1 public class Client {  
 2   
 3     public static void main(String[] args) {  
 4   
 5         //创建节点  
 6         GroupLeader gl = new GroupLeader();  
 7         ProjectManager pm = new ProjectManager();  
 8         DepartmentManager dm = new DepartmentManager();  
 9         CEO ceo = new CEO();  
10         //建立责任链  
11         gl.setHandler(pm);  
12         pm.setHandler(dm);  
13         dm.setHandler(ceo);  
14           
15         //向小组长发出申请，请求审批4天的假期  
16         gl.approve(4D);  
17           
18   
19     }  
20   
21 }

运行结果：

小组长传给了他的上司

项目经理传给了他的上司

部门经理审批通过

　　这里模拟的是一个理想的状态，所以是一个纯的责任链；在实际当中，可能小组长签字，项目经理签字...一堆的签字，而不是不参与请求的处理。

　　责任链模式的优点是调用者不需知道具体谁来处理请求，也不知道链的具体结构，降低了节点域节点的耦合度；可在运行时动态修改链中的对象职责，增强了给对象指派职责的灵活性；缺点是没有明确的接收者，可能传到链的最后，也没得到正确的处理。

责任链模式

原文：http://www.cnblogs.com/lcngu/p/handler.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)