aop鏈式調用

---

多個aop如果疊加
採用了責任鏈的模式

使用ConcerteHandler實現類實現HandleProcess接口同時這個實現類又組合了這個接口，通過successor判斷來進行鏈式調用

---

首先我們新建一個Handler

public abstract class Handler {

    private Handler successor;

    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public void execute(){
        handleProcess();
        if(successor != null){
            successor.execute();
        }
    }

    protected abstract void handleProcess();
}

---

下面我們看看client端實現

public class ChainClient {
    static class HandlerA extends Handler{

        @Override
        protected void handleProcess() {
            System.out.println("handler by a");
        }
    }

    static class HandlerB extends Handler{

        @Override
        protected void handleProcess() {
            System.out.println("handler by b");
        }
    }

    static class HandlerC extends Handler{

        @Override
        protected void handleProcess() {
            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.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);
        handlerA.execute();
    }
}

由此我們實現了鏈式調用，但是我們也發現了每次都需要設置從屬關係。

---

下面我們對上面方法改造，使用另外一個Chain對再下面的代碼進行一次封裝

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

---

下面我們新建一個ChainHandler

public abstract class ChainHandler {

    public void execute(Chain chain){
        handleProcess();
        chain.proceed();
    }
    protected abstract void handleProcess();
}

---

Chain對鏈式關係封裝起來

public class Chain {
    private List<ChainHandler> handlers;

    private int index = 0;

    public Chain(List<ChainHandler> handlers) {
        this.handlers = handlers;
    }
    public void proceed(){
        if(index >= handlers.size()){
            return;
        }
        handlers.get(index++).execute(this);
    }
}

---

下面我們看一下如何實現調用類

public class ChainClient {
    static class ChainHandlerA extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handler by chain a");
        }
    }
    static class ChainHandlerB extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handler by chain b");
        }
    }
    static class ChainHandlerC extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handler by chain c");
        }
    }
    public static void main(String[] args) {
        List<ChainHandler> handlers = Arrays.asList(
                new ChainHandlerA(),
                new ChainHandlerB(),
                new ChainHandlerC()
        );
        Chain chain = new Chain(handlers);
        chain.proceed();
    }
}