Spring AOP原理解析——经典的基于代理的AOP是如何实现的？

Spring实现AOP有4种方式，感兴趣的可以查看下面的博文：
https://blog.csdn.net/u011983531/article/details/49391129

在阅读这篇文章之前，请先行了解一下动态代理的相关知识，因为这是AOP 的基础。

一.经典的基于代理的AOP

首先，我们来看看基于经典的AOP是如何实现的。

先写一个接口叫Sleepable，所有具有睡觉能力的东西都可以实现该接口。

package com.ghs.aop;

public interface Sleepable {
    public void sleep();
}

然后写一个Human类，他实现了这个接口。

package com.ghs.aop;

public class Human implements Sleepable {
    @Override
    public void sleep() {
        System.out.println("正在睡觉！");
    }
}

不过睡觉前后要做些辅助工作，最基本的是脱穿衣服，但是这些动作与纯粹的睡觉这一“业务逻辑”是不相干的，如果把
这些代码全部加入到sleep方法中，是不是有违单一职责呢？，这时候我们就需要AOP了。
编写一个SleepHelper类，它里面包含了睡觉的辅助工作,用AOP术语来说它就应该是通知了。

package com.ghs.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{

    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("睡觉前要脱衣服！");
    }

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("起床后要穿衣服！");
    }
}

配置切点、通知、Human对象的代理。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"
    default-autowire="byName">

    <!-- 定义通知 -->
    <bean id="sleepHelper" class="com.ghs.aop.SleepHelper">
    </bean>

    <!-- 定义切点 -->
    <!-- pattern属性指定了正则表达式，它匹配所有的sleep方法 -->
    <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*sleep"></property>
    </bean>

    <!-- 定义通知者 -->
    <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="sleepHelper"></property>
        <property name="pointcut" ref="sleepPointcut"></property>
    </bean>

    <!-- 产生代理对象 -->
    <bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="human"></property>
        <property name="interceptorNames" value="sleepHelperAdvisor"></property>
        <property name="proxyInterfaces" value="com.ghs.aop.Sleepable"></property>
    </bean>

    <bean id="human" class="com.ghs.aop.Human">
    </bean>
</beans>

类之间的依赖关系，可以看下面的简图。

二.基于代理的AOP实现原理

AOP的实现主要包括下面两大部分：

1. 创建代理
2. 代理执行

Spring动态代理的整体架构，可以查看博文：
https://blog.csdn.net/u011983531/article/details/79649279

ProxyFactoryBean创建代理主要经历了下面几个步骤：

1. 实例化Advisor链
2. 调用代理工厂创建代理

我们主要讲解代理执行的过程：
查看JdkDynamicAopProxy的invoke(…)方法。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Class targetClass = null;
    Object target = null;
    try {
        //equals()、hashcode()等方法不进行代理
        //代码省略……

        Object retVal;

        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        target = targetSource.getTarget();
        if (target != null) {
            targetClass = target.getClass();
        }
        //获取拦截器链
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        if (chain.isEmpty()) {
            //没有拦截器，直接执行目标方法
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
        }
        else {
            //创建可执行对象
            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            //执行
            retVal = invocation.proceed();
        }
        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            retVal = proxy;
        } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
        }
        return retVal;
    }
    finally {
        if (target != null && !targetSource.isStatic()) {
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

主要逻辑就3步：

1. 创建拦截器（通知）链
2. 创建可执行对象
3. 执行可执行对象

我们首先看看拦截器（通知）链是如何创建的。

获取拦截器链其实就是将Advisor链中的所有advice取出来，构造MethodInterceptor对象。如果Advisor.getAdvice()返回的是MethodInterceptor对象，直接加入链中，如果Advisor.getAdvice()返回的Advice对象，通过适配器模型构造MethodInterceptor对象，加入链中。

拦截器链创建好后，构造ReflectiveMethodInvocation对象。
最后就是执行ReflectiveMethodInvocation对象。

//递归调用process方法
public Object proceed() throws Throwable {
    //递归出口：所有的拦截器都已经执行完毕后，执行目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }

    Object interceptorOrInterceptionAdvice =
    this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        }
        else {
            return proceed();
        }
    }
    else {
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

要理解执行逻辑，其实只要弄清楚拦截器链是如何实现链式调用的就行了。Spring在这里使用了递归调用，如何递归的，我们看看几个常见的通知就行了。

//前置通知
public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
    private MethodBeforeAdvice advice;

    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        //执行通知的before方法
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        //递归执行MethodInvocation对象的process()方法
        return mi.proceed();
    }
}

//后置通知
public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {

    private final AfterReturningAdvice advice;

    public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        //递归执行MethodInvocation的proceed()方法
        Object retVal = mi.proceed();
        //执行后置通知的afterReturning()方法
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        return retVal;
    }

}