职责链模式（Chain of Responsibility）的Java实现

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

适用场景：

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；

3、处理一个请求的对象集合应被动态指定。

通用类图：

在大学里面当班干部，时常要向上级申请各方面的东西。譬如申请全班外出秋游，普通同学将申请表交给班长，班长签字之后交给辅导员，辅导员批准之后上交到主任办公室…就是这样，一个请求（这里是一份申请表）有时候需要经过好几个级别的处理者（这里是辅导员、主任）的审查才能够最终被确定可行与否。

在这里表现出来的是一个职责链，即不同的处理者对同一个请求可能担负着不同的处理方式、权限，但是我们希望这个请求必须到达最终拍板的处理者（否则秋游就没戏了）。这种关系就很适合使用职责链模式了。

类图结构如下：

 代码实现如下：

1. // 全局变量，接口类型  
2. /**  
3.  * 使用Java中的interface定义全局变量，可根据具体需要在   
4.  * 具体的包中使用静态导入相关的全局变量，语法如下：   
5.  *  import static package01.package02.*;  
6.  */ 
7. interface Levels {  
8.     public static final int LEVEL_01 = 1;  
9.     public static final int LEVEL_02 = 2;  
10.     public static final int LEVEL_03 = 3;  
11. } 

1. // 抽象请求类  
2. abstract class AbstractRequest {  
3.     private String content = null;  
4.  
5.     public AbstractRequest(String content) {  
6.         this.content = content;  
7.     }  
8.  
9.     public String getContent() {  
10.         return this.content;  
11.     }  
12.  
13.     // 获得请求的级别  
14.     public abstract int getRequestLevel();  
15. } 

1. // 具体请求类01  
2. class Request01 extends AbstractRequest {  
3.     public Request01(String content) {  
4.         super(content);  
5.     }  
6.  
7.     @Override 
8.     public int getRequestLevel() {  
9.         return Levels.LEVEL_01;  
10.     }  
11. }  
12.  
13. // 具体请求类02  
14. class Request02 extends AbstractRequest {  
15.     public Request02(String content) {  
16.         super(content);  
17.     }  
18.  
19.     @Override 
20.     public int getRequestLevel() {  
21.         return Levels.LEVEL_02;  
22.     }  
23. }  
24.  
25. // 具体请求类03  
26. class Request03 extends AbstractRequest {  
27.     public Request03(String content) {  
28.         super(content);  
29.     }  
30.  
31.     @Override 
32.     public int getRequestLevel() {  
33.         return Levels.LEVEL_03;  
34.     }  
35. } 

1. // 抽象处理者类，  
2. abstract class AbstractHandler {  
3.     // 责任链的下一个节点，即处理者  
4.     private AbstractHandler nextHandler = null;  
5.  
6.     // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别  
7.     public final void handleRequest(AbstractRequest request) {  
8.  
9.         // 若该请求与当前处理者的级别层次相对应，则由自己进行处理  
10.         if (this.getHandlerLevel() == request.getRequestLevel()) {  
11.             this.handle(request);  
12.         } else {  
13.             // 当前处理者不能胜任，则传递至职责链的下一节点  
14.             if (this.nextHandler != null) {  
15.                 System.out.println("当前 处理者-0" + this.getHandlerLevel()  
16.                         + " 不足以处理 请求-0" + request.getRequestLevel());  
17.                   
18.                 // 这里使用了递归调用  
19.                 this.nextHandler.handleRequest(request);  
20.             } else {  
21.                 System.out.println("职责链上的所有处理者都不能胜任该请求...");  
22.             }  
23.         }  
24.     }  
25.  
26.     // 设置责任链中的下一个处理者  
27.     public void setNextHandler(AbstractHandler nextHandler) {  
28.         this.nextHandler = nextHandler;  
29.     }  
30.  
31.     // 获取当前处理者的级别  
32.     protected abstract int getHandlerLevel();  
33.  
34.     // 定义链中每个处理者具体的处理方式  
35.     protected abstract void handle(AbstractRequest request);  
36. } 

1. // 具体处理者-01  
2. class Handler01 extends AbstractHandler {  
3.     @Override 
4.     protected int getHandlerLevel() {  
5.         return Levels.LEVEL_01;  
6.     }  
7.  
8.     @Override 
9.     protected void handle(AbstractRequest request) {  
10.         System.out.println("处理者-01 处理 " + request.getContent() + "\n");  
11.     }  
12. }  
13.  
14. // 具体处理者-02  
15. class Handler02 extends AbstractHandler {  
16.     @Override 
17.     protected int getHandlerLevel() {  
18.         return Levels.LEVEL_02;  
19.     }  
20.  
21.     @Override 
22.     protected void handle(AbstractRequest request) {  
23.         System.out.println("处理者-02 处理 " + request.getContent()+ "\n");  
24.     }  
25. }  
26.  
27. // 具体处理者-03  
28. class Handler03 extends AbstractHandler {  
29.     @Override 
30.     protected int getHandlerLevel() {  
31.         return Levels.LEVEL_03;  
32.     }  
33.  
34.     @Override 
35.     protected void handle(AbstractRequest request) {  
36.         System.out.println("处理者-03 处理 " + request.getContent()+ "\n");  
37.     }  
38. } 

1. // 测试类  
2. public class Client {  
3.     public static void main(String[] args) {  
4.         // 创建指责链的所有节点  
5.         AbstractHandler handler01 = new Handler01();  
6.         AbstractHandler handler02 = new Handler02();  
7.         AbstractHandler handler03 = new Handler03();  
8.  
9.         // 进行链的组装，即头尾相连，一层套一层  
10.         handler01.setNextHandler(handler02);  
11.         handler02.setNextHandler(handler03);  
12.  
13.         // 创建请求并提交到指责链中进行处理  
14.         AbstractRequest request01 = new Request01("请求-01");  
15.         AbstractRequest request02 = new Request02("请求-02");  
16.         AbstractRequest request03 = new Request03("请求-03");  
17.           
18.         // 每次提交都是从链头开始遍历  
19.         handler01.handleRequest(request01);  
20.         handler01.handleRequest(request02);  
21.         handler01.handleRequest(request03);  
22.     }  
23. } 

测试结果：

1. 处理者-01 处理 请求-01 
2.  
3. 当前 处理者-01 不足以处理 请求-02 
4. 处理者-02 处理 请求-02 
5.  
6. 当前 处理者-01 不足以处理 请求-03 
7. 当前 处理者-02 不足以处理 请求-03 
8. 处理者-03 处理 请求-03 

1、对于每一个请求都需要遍历职责链，性能是个问题；

2、抽象处理者 AbstractHandler 类中的 handleRequest() 方法中使用了递归，栈空间的大小也是个问题。

 个人看法：

职责链模式对于请求的处理是不知道最终处理者是谁，所以是运行动态寻找并指定；而命令模式中对于命令的处理时在创建命令是已经显式或隐式绑定了接收者。

本文转自 xxxx66yyyy 51CTO博客，原文链接：http://blog.51cto.com/haolloyin/342166，如需转载请自行联系原作者