設計模式——責任鏈模式

時間 2019-11-13

標籤設計模式責任简体版

原文原文鏈接

探祕Spring AOP

1、責任鏈模式

原理：

責任鏈模式：若是有多個對象都有機會處理請求，責任鏈可以使請求的發送者和接收者解耦，請求沿着責任spring

鏈，直到有一個對象處理了它爲止。ide

優勢：

將請求的發送者和接收者解耦，使多個對象都有機會處理這個請求。性能
能夠簡化對象，由於它無需知道鏈的結構。this
能夠動態的增長或刪減處理請求的鏈結構。code

缺點：

請求從鏈的開頭進行遍歷，對性能有必定的損耗對象
並不保證請求必定被處理遞歸

適用場景：

有多個對象能夠處理一個請求。圖片
不明確接收者的狀況。get
有序，無序鏈，線型，樹型，環形鏈。it

2、責任鏈模式代碼演示 1

sucessor 綁定 ConcreteHandler 與 Handler,ConcreteHandler 實現抽象方法

public abstract class Handler {

     /** 
         * 持有後繼的責任對象 
         */ 
    private Handler sucessor;

/** 
     * 取值方法 
     */
    public Handler getSucessor() {
        return sucessor;
    }

  /** 
     * 賦值方法，設置後繼的責任對象 
     */ 
    public void setSucessor(Handler sucessor) {
        this.sucessor = sucessor;
    }

    public void execute(){
        handlerProcess();
       /** 
          * 判斷是否有後繼的責任對象 
          * 若是有，就轉發請求給後繼的責任對象 
          * 若是沒有，則處理請求 
          */  
        if(sucessor != null){
            sucessor.execute();
        }
    }

 /** 
     * 示意處理請求的方法，雖然這個示意方法是沒有傳入參數的 
     * 但實際是能夠傳入參數的，根據具體須要來選擇是否傳遞參數 
     */  
    protected abstract void handlerProcess();
}

客戶端調用

public class Client {

    static class HandlerA extends Handler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by a");
        }
    }

    static class HandlerB extends Handler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by b");
        }
    }

    static class HandlerC extends Handler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by c");
        }
    }

    public static void main(String[] args) {
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        Handler handlerC = new HandlerC();

        handlerA.setSucessor(handlerB);
        handlerB.setSucessor(handlerC);

        handlerA.execute();
    }
}

3、責任鏈模式代碼演示 2

封裝鏈式關係

public class Chain {

    private List<ChainHandler> handlers;

    private int index = 0;

    public Chain(List<ChainHandler> handlers) {
        this.handlers = handlers;
    }

    public void process() {
        if(index >= handlers.size()){
            return;
        }
        handlers.get(index++).execute(this);
    }
}

抽象handler 遞歸執行方法

public abstract class ChainHandler {

    public void execute (Chain chain){
        handlerProcess();
        chain.process();
    }

    protected abstract void handlerProcess();
}

客戶端調用

public class ChainClient {

    static class HandlerA extends ChainHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by a");
        }
    }

    static class HandlerB extends ChainHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by b");
        }
    }

    static class HandlerC extends ChainHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by c");
        }
    }

    public static void main(String[] args) {
        List<ChainHandler> handlers = Arrays.asList(
                new HandlerA(),
                new HandlerB(),
                new HandlerC()
        );

        Chain chain = new Chain(handlers);
        chain.process();
    }
}