aop学习笔记之Aop责任链（四）

一 Aop责任链

如何理解责任链呢？当一个切面有多个织入时，这些需要织入的方法就形成了一个责任链，就像Filter链一样

二 原理

看了上图我们理解一下，责任链中包含每一个Handler，那每个Hanlder在执行之后，程序是怎么知道下次要执行哪个Handler呢？我们先做出假设，每个Handler中存储着NextHandler，这样程序就知道下次执行哪个了

三 责任链实现

3.1 BaseHandler

首先我们创建一个BaseHandler类

package com.example.proxy.chain;

/**
 * BaseHandler class
 *
 * @author TransientBa
 * @date 2018/3/10
 */
public abstract class BaseHandler {
    /**
     * 用来存储下一个Handler
     */
    private BaseHandler nextHandler;

    public BaseHandler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    /** 如果nextHandler不为空  则执行下一个Handler**/
    public void execute(){
        handlerProcess();
        if( nextHandler != null){
            nextHandler.execute();
        }
    }

    /**
     * Handler
     * @return void
     */
    protected abstract void handlerProcess();
}

依据我们上面的假设，类中有一个nextHandler属性，我们假设他用来保存下一个Handler。
还有一个抽象方法handlerProcess（），此方法用来被继承后写执行过程。
最后在execute（）中我们先执行本次Handler中的handlerProcess，然后判断NextHandler是否为空，如果不为空。则执行NextHandler也就是下一个Handler的方法。

3.2 Client测试

在这个类中我们首先创建三个Handler来继承上面的BaseHandler类，重写其中的handlerProcess方法
，然后在实例化三个雷，并将它们按照顺序赋值给各自的NextHandler，然后我们执行一下

package com.example.proxy.chain;

/**
 * Client class
 *
 * @author TransientBa
 * @date 2018/3/12
 */
public class Client {
    /**创建ABC三个Handler来继承BaseHandler**/
    static class HandlerA extends BaseHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handle by a");
        }
    }
    static class HandlerB extends BaseHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handle by b");
        }
    }
    static class HandlerC extends BaseHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handle by c");
        }
    }

    public static void main(String[] args) {
        BaseHandler handlerA = new HandlerA();
        BaseHandler handlerB = new HandlerB();
        BaseHandler handlerC = new HandlerC();
        /**
         * 将下个Handler赋值给当前Handler中的NextHandler属性
         * 有点像HashMap中的Node  每个Node存储着下一个Node
         */
        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);
        handlerA.execute();

    }


}

执行结果

3.3 优化

看到这里是不是已经发现了问题所在，这样虽然实现了整个链式的调用，但当我们实例化三个Handler后，需要手动的将每个Handler之前的关系表明，也就是赋值NextHandler，这样很麻烦，实现起来也不现实。那我们如何改进呢？

3.4 Chain

这里创建一个chain类，这个类用来做什么呢？我们将上面的BaseHandler类拆分为ChainBaseHandler类和Chain类两个类来实现链式调用

package com.example.proxy.chain;

import java.util.List;

/**
 * Chain class
 *
 * @author TransientBa
 * @date 2018/3/12
 */
public class Chain {
    private List handlers;
    /**
     * 用来表示handlers的游标
     */
    private int index = -1;

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

    /**
     * 通过index自增 调用excute实现递归  遍历整个handlers
     */
    public void proceed(){
        if(index == handlers.size() - 1){
            return;
        }
        handlers.get(++index).execute(this);
    }
}

可以看到，在chain中我们取消了NextHandler属性，而是改用了一个List,类型是ChainBaseHandler，
还多了一个index，初始值为-1，
然后是一个构造，在实例化时要传入一个List进来，并赋值给该类的handlers属性，
最后是proceed方法，在这个方法中我们首先判断了index是否超过List的size，如果超过了则返回，如果没操作，就得到当索引的Handler，然后执行ChainBaseHandler中的execute方法

3.5 ChainBaseHandler

在这个类中我们只有两个方法，execute和handlerProcess，其中handlerProcess依然用来被继承后写执行过程。
execute方法有一个参数Chain，这个方法首先进来会执行当前Handler的HandlerProcess执行过程，然后会调用传入Chain的proceed方法，这样调用就又回到了proceed中，继续判断index并开始下一次循环

package com.example.proxy.chain;

/**
 * ChainBaseHandler class
 *
 * @author TransientBa
 * @date 2018/3/12
 */
public abstract class ChainBaseHandler {
    /**同样先执行自己的动作 再调用chain的proceed去遍历下一个Handler**/
    public void execute(Chain chain){
        handlerProcess();
        chain.proceed();
    };
    protected abstract void handlerProcess();
}

3.6ChainClient测试

package com.example.proxy.chain;

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

/**
 * ChainClient class
 *
 * @author TransientBa
 * @date 2018/3/12
 */
public class ChainClient {
    static class ChainHandlerA extends ChainBaseHandler{
        @Override
        protected void handlerProcess() {
            System.out.println("handler by chain a");
        }
    }

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

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

    public static void main(String[] args) {
        /**
         * 声明HandlerList关系链 通过数组顺序排序
         * 不再像之前那样手动给当前Handler中的NextHandler设置值
         * 同样每个chain中间没有相互的依赖 实现解耦
         */
        List handlerList = Arrays.asList(
                new ChainHandlerA(),
                new ChainHandlerB(),
                new ChainHandlerC()
        );

        Chain chain = new Chain(handlerList);
        chain.proceed();

    }
}

在这个类中我们同样先创建三个类继承ChainBaseHandler，重写handlerProcess方法，
然后用Arrays.asList来初始一个handlerList，并传入Chain的构造，实例化出来一个Chain，调用proceed方法开始遍历，
执行一下：

四 ReflectiveMethodInvocation

上面我们用代码模拟了Aop的责任链，接下来我们看看源码中Aop责任链是如何实现的，该类位于org.springframework.aop.framework下

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.aop.framework;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.ProxyMethodInvocation;
import org.springframework.aop.support.AopUtils;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.lang.Nullable;

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
    protected final Object proxy;
    @Nullable
    protected final Object target;
    protected final Method method;
    protected Object[] arguments = new Object[0];
    @Nullable
    private final Class targetClass;
    @Nullable
    private Map userAttributes;
    protected final List interceptorsAndDynamicMethodMatchers;
    private int currentInterceptorIndex = -1;

    protected ReflectiveMethodInvocation(Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments, @Nullable Class targetClass, List