一天一種設計模式之十-----職責鏈模式

一.職責鏈模式簡介

1.  職責鏈模式屬於行爲型模式。

2. 使多個對象都有機會處理請求，從而避免了請求的發送者與接收者之間的耦合關係。將這些對象連城一條鏈，並沿着這條鏈傳遞該請求，直到有對象處理它爲止。

3. 先看一段簡單的代碼

4. public void test(int i,Request request){
           if(i==1){
               Handler1.doHandle(request);
           }else if(i==2){
               Handler2.doHandle(request);
           }else if(i==3){
               //xxx
           }else if(i==4){
           }
           //......
       }

5. 上述代碼存在如下硬傷

1. 代碼臃腫：實際應用中的斷定條件一般不是簡單的判斷1或者2，而是須要複雜的計算以及對數據庫的查詢。這樣會有不少判斷條件ifelse，代碼可讀性低。
   

2. 耦合度高

6. 職責鏈模式就是爲了解決上述硬傷的。它的結構以下

1. 抽象處理類：抽象處理類中主要包含一個指向下一處理類的成員變量nextHandler和一個處理請求的方法handRequest，handRequest方法的主要思想是，若是知足處理條件，則由本類來進行處理類，若是不知足，則由nextHandler處理。

2. 具體處理類：具體處理類主要是對具體的處理邏輯進行判斷和處理。

7. 職責鏈模式優勢

1. 與if else 相比，它的耦合度要低，由於它把條件斷定都分散到了各個處理類中，而且這些處理類的優先處理順序能夠隨意設定。

8. 職責鏈模式缺點

1. 在找到正確的處理類以前，全部的斷定條件都要被執行一遍，當職責鏈比較長時，性能問題比較嚴重。

9. 適用場景主要是替換ifelse。

10. 感受職責鏈模式比屬於結構型模式的裝飾模式只多了一個判斷類，用於判斷是否由本個handler處理仍是由下一個處理。（我的理解，歡迎指正）
    

11. 當心引發死循環。
    

二.測試代碼

1. 測試代碼以下：

2. public class ZhizelianTest {
       public static void main(String[] args) {
           Handler handler1=new ConcreteHandler1();
           Handler handler2=new ConcreteHandler2();
           Handler handler3=new ConcreteHandler3();
           handler1.setNextHandler(handler2);
           handler2.setNextHandler(handler3);
           Response response=handler1.handleRequest(new Request(new Level(4)));
           
       }
   }
   class Level{
       private int level =0;
       public Level(int level){
           this.level=level;
       }
       public boolean above(Level level){
           if(this.level>=level.level){
               return true;
           }
           return false;
       }
   }
   class Request{
       Level level;
       public Request(Level level){
           this.level=level;
       }
       public Level getLevel() {
           return level;
       }
   }
   class Response{
       
   }
   abstract class Handler{
       private Handler nextHandler;
       public final Response handleRequest(Request request){
           Response response=null;
           if(this.getHandlerLevel().above(request.getLevel())){
               response=this.response(request);
           }else {
               if(this.nextHandler!=null){
                   this.nextHandler.handleRequest(request);
               }else {
                   System.out.println("沒有合適的處理器處理");
               }
           }
           return response;
       }
       public void setNextHandler(Handler nextHandler) {
           this.nextHandler = nextHandler;
       }
       protected abstract Level getHandlerLevel();
       public abstract Response response(Request request); 
   }
   class ConcreteHandler1 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(1);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---請求由處理器1進行處理");
           return null;
       }
   
   }
   class ConcreteHandler2 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(3);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---請求由處理器3進行處理");
           return null;
       }
   
   }
   class ConcreteHandler3 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(5);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---請求由處理器5進行處理");
           return null;
       }
   
   }

3. 代碼中level類是模擬的判斷條件；request，response分別對應請求和相應；抽象類Handler中主要進行條件的判斷，這裏模擬一個處理等級，只有處理類的處理等級高於request的等級才進行處理。完成ifelse功能。