设计模式之职责链模式(JAVA实现)

学习netty框架时，看到有人说netty用到了设计模式的职责链模式，学习一下职责链模式，主要参考大话设计模式。

主要场景：

小菜想要加薪，向经理提出加薪请求，经理没有权限，经理交由总监处理，总监也没有权限，交由总经理处理，最后，总经理处理了，不同意。

职责链的意思就是，如果没有处理该类请求的权限，交由具有更高权限的对象处理。依次类推

这里将处理对象抽象为Handler类，经理、总监等为继承Handler的具体处理类，同时模拟客户端Client向Handler对象发出请求

类图如下

下面为具体代码实现：

Handler.java

 1 /**
 2  * 抽象的处理类
 3  * @author GXF
 4  *
 5  */
 6 public abstract class Handler {
 7     public Handler successor;                            //后继者，或权限更高的对象
 8     public abstract void handleRequest(int request);    //处理客户端请求
 9
10     public void setSuccesor(Handler successor){            //设置后继者，或者更高权限的对象
11         this.successor = successor;
12     }
13
14 }

ConcreteHandler1.java

 1 /**
 2  * 具体处理类1
 3  * 处理请求范围在1～10之间的请求
 4  * @author GXF
 5  *
 6  */
 7 public class ConcreteHandler1 extends Handler {
 8
 9     @Override
10     public void handleRequest(int request) {
11         if(request >=0 && request <= 10){                //在自己的权限范围内，自己处理
12             System.out.println("ConcreteHandler1 handle request = " + request);
13         }
14         else if(successor != null){                        //超过自己的权限，如果有更高权限对象，交由其处理
15             successor.handleRequest(request);
16         }
17
18     }
19
20 }

ConcreteHandler2.java

 1 /**
 2  * 具体处理类
 3  * 处理reqeuest 10～20范围
 4  * @author GXF
 5  *
 6  */
 7 public class ConcreteHandler2 extends Handler {
 8
 9     @Override
10     public void handleRequest(int request) {
11         if(request > 10 && request <= 20){                    //处理权限范围内的请求
12             System.out.println("ConcreteHandler2 handle request = " + request);
13         }
14         else if(successor != null){                            //不能处理的请求，交由权限更高的处理对象处理
15             successor.handleRequest(request);
16         }
17     }
18
19 }

ConcreteHandler3.java

 1 /**
 2  * 具体处理类3
 3  * 处理request范围:20~30
 4  * @author GXF
 5  *
 6  */
 7 public class ConcreteHandler3 extends Handler {
 8
 9     @Override
10     public void handleRequest(int request) {
11         if(request > 20 && request <= 30){
12             System.out.println("ConcreteHandler3 handle request = " + request);
13         }
14         else if(successor != null){
15             successor.handleRequest(request);
16         }
17
18     }
19
20 }

Client.java

 1 /**
 2  * 职责链模式客户端
 3  * @author GXF
 4  *
 5  */
 6 public class Client {
 7
 8     public static void main(String args[]){
 9         //生成三个权限的处理者对象
10         Handler h1 = new ConcreteHandler1();
11         Handler h2 = new ConcreteHandler2();
12         Handler h3 = new ConcreteHandler3();
13
14         //设置职责链后继者
15         h1.setSuccesor(h2);
16         h2.setSuccesor(h3);
17
18          //生成1-30的数字，作为请求，交由handler处理
19         int requests[] = new int[30];
20
21         //初始化reqeusts数组
22         for(int i = 0; i < requests.length; i++){
23             requests[i] = i;
24         }
25
26         for(int i = 0 ; i < requests.length; i++){
27             h1.handleRequest(requests[i]);
28         }//for
29
30     }
31
32 }