設計模式-行為型模式-責任鏈模式

定義

將請求沿著鏈傳遞，然後直到物件處理即可。

UML圖

程式碼

基本的責任鏈

public class Test{
    public void test(int i, Request request){
        if(i == 1){
            Hander1.response(request);
        }
        
        if(i == 2){
            Hander2.response(request);
        }
        
        if(i == 3){
            Hander3.requese(request);
        }
    }
}
 

程式碼邏輯如上，只處理1，2,3情況，其餘的情況都不處理。

責任鏈

// 物件
public 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;
        else
            return false;
    }
}

// 將物件進行封裝
public class Request{
    Level level;
    public Request(Level level){
        this.level = level;
    }
    public Level getLevel(){
        return level;
    }
}

// 返回訊息
public class Response{}

public 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 handler){
        this.nextHandler = handler;
    }
    // 當前處理器
    protected abstract Level getHandlerLvel();
    // 進入處理器處理
    public abstract Response response(Request request);
}

// 第一個處理器
public class ConcreteHandler1 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(1);
    }
    public Response response(Request request){
        System.out.println("處理1處理");
        return null;    // 下一個處理器為空
    }
}

// 第二個處理器
public class ConcreteHandler2 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(3);
    }
    public Response response(Request request){
        System.out.println("處理1處理");
        return null;    // 下一個處理器為空
    }
}

// 第三個處理器
public class ConcreteHandler3 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(5);
    }
    public Response response(Request request){
        System.out.println("處理1處理");
        return null;    // 下一個處理器為空
    }
}

// 最後定義場景
public class Client{
    public static void main(String[] args){
        // 新建處理器
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        
        // 設定下一個處理器
        // 處理器處理邏輯為先處理1，再處理2，再處理3
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        
        // 進行處理
        Response response = handler1.handlerRequest(new Request(new Level(4)));
    }
}
 

總結

責任鏈模式核心在處理流，讓物件在類之間流動，直到合適進行物件處理，並把下一個設定為空。
寫法，當然就是新建幾個處理器類，然後要處理的物件，處理類之間用next指向下一個，然後把處理的物件傳入進去，如果找到合適的處理器，進行處理，並將下一個設定為空，完成責任鏈。
其中，幾個處理器類可以抽象出一個抽象類，並把物件進行封裝成一個類，以上為上方程式碼的設計思路。

應用

開發一個電商網站，支付過500元定金的使用者，收到100元優惠卷，200元收到50元，沒有支付過的，進入普通模式購買。
如果不用職責鏈，需要寫入一大堆if語句。
將if語句拆分，使用職責鏈，將處理器類抽象出來，然後將購買的使用者傳入處理器，然後如果處理完成，下一個設定為空，返回結果。
另外一個應用，檔案上傳，使用的也是職責鏈。