Spring AOP中的职责链模式

1. 职责链模式（Chain Of Responsibility Design Pattern）

在职责链模式中，多个处理器（也就是刚刚定义中说的“接收对象”）依次处理同一个请求。一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B 处理器处理完后再传递给 C 处理器，以此类推，形成一个链条。链条上的每个处理器各自承担各自的处理职责，所以叫作职责链模式。

IHandler是所有处理器类的接口，handle()方法是抽象方法，每个具体的处理器类（HandlerA、HandlerB）的handle()方法用来处理请求，HandlerChain是处理器链，代码如下所示：


public interface IHandler {
  boolean handle();
}

public class HandlerA implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerChain {
  private List<IHandler> handlers = new ArrayList<>();

  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }

  public void handle() {
    for (IHandler handler : handlers) {
      boolean handled = handler.handle();
      if (handled) {
        break;
      }
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

2. Spring AOP的基本使用和源码解析

Spring AOP的基本使用请参考：SpringAOP
Spring AOP源码解析请参考：Spring AOP源码浅析

3.Spring AOP的职责链模式

3.1. MethodInteceptor接口

相当于上文中的IHandler，每个处理器都要实现该接口，其中invoke()方法，是处理器的处理逻辑

public interface MethodInteceptor {

    Object invoke(MethodInvocation mi) throws Throwable;

}

3.2. CglibMethodInvocation

CglibMethodInvocation相当于上文中的HandlerChain ，该类中定义了拦截器链以及拦截器链的执行逻辑，代码模拟了Spring AOP的处理

public class CglibMethodInvocation implements MethodInvocation{

    List<MethodInteceptor> inteceptors;
    //当前拦截器链执行的位置。
    int currentInterceptorIndex = -1;

    //要切入的目标类对象，方法，方法参数
    Object target;
    Method method;
    Object[] args;

    CglibMethodInvocation(List<MethodInteceptor> inteceptors, Object target, Method method,Object[] args){
        this.inteceptors = inteceptors;
        this.target = target;
        this.method = method;
        this.args = args;
    }


    @Override
    public Object proceed() throws Throwable {
        //当拦截器链执行完之后，就执行目标类的目标方法。
        if (this.currentInterceptorIndex == this.inteceptors.size() - 1) {
            return method.invoke(target,args);
        }

        MethodInteceptor inteceptor = this.inteceptors.get(++currentInterceptorIndex);

        return inteceptor.invoke(this);
    }
}

3.3. MethodInvocation

MethodInvocation是CglibMethodInvocation的抽象。

public interface MethodInvocation {

    Object proceed() throws Throwable;
}

3.4. MethodInteceptor的实现类

MethodInteceptor的实现类就是拦截器的具体实现，在每个invoke(MethodInvocation mi)方法中，都会调用mi.proceed()方法，让拦截器链能够继续往下执行。

public class MethodBeforeAdviceInterceptor implements MethodInteceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("假装这里执行了切面类@Before标注的方法。。。。。。。");
        return mi.proceed();
    }
}

public class AspectJAfterAdvice implements MethodInteceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        try{
            return mi.proceed();
        }
        finally {
            System.out.println("假装这里执行了切面类@After标注的方法。。。。。。");
        }
    }
}

public class AfterReturningAdviceInterceptor implements MethodInteceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        Object returnVal = mi.proceed();
        System.out.println("假装这里执行了切面类@AfterReturning标注的方法。。。。。。");
        return returnVal;
    }
}

public class AspectJAfterThrowingAdvice implements MethodInteceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        try{
            return mi.proceed();
        }catch (Throwable throwable){
            System.out.println("假装执行了切面类@AfterThrowing标注的方法");
            throw throwable;
        }
    }
}

3.5. TargetClass目标类

TargetClass目标类就是简单模拟一下，Spring AOP中要被切入的类。

public class TargetClass {

    public void targetMethod(String s){
        //先简单抛个异常
        //int i = 1 / 0;
        System.out.println("假装这里执行了目标类的目标方法,传参："+s);
    }
}

3.6. 测试类MainClass

public class MainClass {
    public static void main(String[] args) throws Throwable {
        //初始化拦截器
        List<MethodInteceptor> inteceptors = new ArrayList<>(4);
        inteceptors.add(new AspectJAfterThrowingAdvice());
        inteceptors.add(new AfterReturningAdviceInterceptor());
        inteceptors.add(new AspectJAfterAdvice());
        inteceptors.add(new MethodBeforeAdviceInterceptor());

        //利用反射获取目标类以及目标方法，然后初始化参数
        TargetClass targetClass = new TargetClass();
        Method method = targetClass.getClass().getMethod("targetMethod",String.class);
        Object[] methodArgs = {"我是参数"};

        //执行职责链
        CglibMethodInvocation methodInvocation = new CglibMethodInvocation(inteceptors,targetClass,method,methodArgs);
        methodInvocation.proceed();
    }
}

3.7. 测试结果

先注掉TargetClass中的int i = 1 / 0：

假装这里执行了切面类@Before标注的方法。。。。。。。
假装这里执行了目标类的目标方法,传参：我是参数
假装这里执行了切面类@After标注的方法。。。。。。
假装这里执行了切面类@AfterReturning标注的方法。。。。。。

Process finished with exit code 0

放开注释，让目标方法抛个异常：

假装这里执行了切面类@Before标注的方法。。。。。。。
假装这里执行了切面类@After标注的方法。。。。。。
假装执行了切面类@AfterThrowing标注的方法
Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ljessie.designpattern.behavior.chain.CglibMethodInvocation.proceed(CglibMethodInvocation.java:25)
    at com.ljessie.designpattern.behavior.chain.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:7)
    at com.ljessie.designpattern.behavior.chain.CglibMethodInvocation.proceed(CglibMethodInvocation.java:30)
    at com.ljessie.designpattern.behavior.chain.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:7)
    at com.ljessie.designpattern.behavior.chain.CglibMethodInvocation.proceed(CglibMethodInvocation.java:30)
    at com.ljessie.designpattern.behavior.chain.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:6)
    at com.ljessie.designpattern.behavior.chain.CglibMethodInvocation.proceed(CglibMethodInvocation.java:30)
    at com.ljessie.designpattern.behavior.chain.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:7)
    at com.ljessie.designpattern.behavior.chain.CglibMethodInvocation.proceed(CglibMethodInvocation.java:30)
    at com.ljessie.designpattern.behavior.chain.MainClass.main(MainClass.java:23)
Caused by: java.lang.ArithmeticException: / by zero
    at com.ljessie.designpattern.behavior.chain.TargetClass.targetMethod(TargetClass.java:9)
    ... 14 more

Process finished with exit code 1

到这里，拦截器链的执行逻辑与Spring AOP基本相符。在目标方法没有抛出异常时，会走AfterReturning方法；抛出异常时，会走AfterThrowing方法。

4. 总结

本文从Spring AOP的源码中，抽取出来职责链模式相关代码，简单介绍了下Spring AOP中职责链模式的应用。

在Spring AOP中，MethodInterceptor是所有拦截器的抽象接口，然后各个拦截器实现了MethodInterceptor接口。

CglibMethodInvocation是中的proceed()方法，定义了拦截器链的处理逻辑，当所有拦截器都执行完毕之后，开始执行目标类的目标方法。MethodInvocation接口是CglibMethodInvocation的抽象。

如有分析不当之处，还烦请各位看官多多指正。