当多个AOP作用在同一个对象是如何叠加的

采用责任链模式

责任链模式

Client调用Handler，Handler中有一个抽象的HandleProcess()方法，需要由实现类实现，实现类又组合了Handler，通过successor判断实现链式调用。

简单示例

工程结构

Handler

package dev.wj.springaopdemo.chain;

/**
 * @Author: WJ
 * @Description:
 * @Date: Created in 上午10:03 2018/1/30
 */
public abstract class Handler {

    /**
     * 用于判断接下来是否还有处理
     */
    private Handler successor;

    /**
     * 由子类去实现
     */
    protected abstract void handleProcess();

    /**
     * 该方法对外暴露，实现链式调用
     */
    public void execute() {
        handleProcess(); //首先处理自己的handleProcess
        if (successor != null) {
            successor.execute(); //判断successor不为空则继续调用successor的execute()方法
        }
    }

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

客户端

package dev.wj.springaopdemo.chain;

/**
 * @Author: WJ
 * @Description:
 * @Date: Created in 上午10:07 2018/1/30
 */
public class Client {

    /**构造几个Handler的实现*/
    static class HandlerA extends Handler {
        @Override
        protected void handleProcess() {
            System.out.println("Handle by A");
        }
    }

    static class HandlerB extends  Handler {
        @Override
        protected void handleProcess() {
            System.out.println("Handle by B");
        }
    }

    static class HandlerC extends  Handler {
        @Override
        protected void handleProcess() {
            System.out.println("Handle by C");
        }
    }

    public static void main(String[] args) {

        //示例话Handler实现类
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        Handler handlerC = new HandlerC();

        //设置调用关系
        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);

        //从第一个开始执行
        handlerA.execute();
    }

}

执行结果

在这个例子中，每次都要手动设置调用关系。针对这点进行改进。

改进示例--仿Spring实现

将上个例子中的调用关系设置代码封装。

项目结构

Chain 封装调用链

package dev.wj.springaopdemo.chain;

import java.util.List;

/**
 * @Author: WJ
 * @Description: 封装调用链
 * @Date: Created in 上午11:16 2018/1/30
 */
public class Chain {

    /**封装顺序关系*/
    private List<ChainHandler> handlers;

    /**标记顺序序号*/
    private int index = 0;

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

    /**暴露给客户端调用*/
    public void proceed() {

        /**
         * 维护index，遍历handler
         * 调用execute()方法实现递归
         */
        if (index >= handlers.size()) {
            return ;
        }
        handlers.get(index++).execute(this);
    }
}

ChainHandler


package dev.wj.springaopdemo.chain;

/**
 * @Author: WJ
 * @Description:
 * @Date: Created in 上午11:15 2018/1/30
 */
public abstract class ChainHandler {

    /**
     * 递归地执行调用链
     * @param chain
     */
    public void execute(Chain chain) {
        handleProcess();
        chain.proceed();
    }

    /**
     * 由子类去实现
     */
    protected abstract void handleProcess();
}

客户端

package dev.wj.springaopdemo.chain;

import java.util.Arrays;
import java.util.List;

/**
 * @Author: WJ
 * @Description: 客户端
 * @Date: Created in 上午11:21 2018/1/30
 */
public class ChainClient {

    /**构造几个Handler的实现*/
    static class ChainHandlerA extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("Handled By A");
        }
    }

    static class ChainHandlerB extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("Handled By B");
        }
    }

    static class ChainHandlerC extends ChainHandler {
        @Override
        protected void handleProcess() {
            System.out.println("Handled By 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();
    }
}