《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）

2023-10-22 大全 26 作者：考证青年

0、前言在上篇文章《设计思想》AOP设计基本原理中阐述了 AOP 的基本原理以及基本机制，本文将深入源码，详细阐述整个 AOP实现的整个过程。

读完本文，你将了解到：

1、内部创建代理对象的过程

2、 AOP的核心---

3、基于JDK面向接口的动态代理生成代理对象

4、基于Cglib子类继承方式的动态代理生成代理对象

5、各种是的执行顺序是如何和方法调用进行结合的？

6、与的结合------的条件执行

7、总结

1、内部创建代理对象的过程

在的底层，如果我们配置了代理模式，会为每一个Bean创建一个对应的的来创建某个对象的代理对象。

假定我们现在有一个接口及其实现类，我们打算创建一个代理类，在执行的方法时的各个阶段，插入对应的业务代码。

package org.luanlouis.meditations.thinkinginspring.aop;/*** 售票服务* Created by louis on 2016/4/14.*/
public interface TicketService {//售票public void sellTicket();//问询public void inquire();//退票public void withdraw();
}

package org.luanlouis.meditations.thinkinginspring.aop;/*** RailwayStation 实现 TicketService* Created by louis on 2016/4/14.*/
public class RailwayStation implements TicketService {public void sellTicket(){System.out.println("售票............");}public void inquire() {System.out.println("问询.............");}public void withdraw() {System.out.println("退票.............");}
}

package org.luanlouis.meditations.thinkinginspring.aop;import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;/*** 执行RealSubject对象的方法之前的处理意见* Created by louis on 2016/4/14.*/
public class TicketServiceBeforeAdvice implements MethodBeforeAdvice {public void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("BEFORE_ADVICE: 欢迎光临代售点....");}
}

package org.luanlouis.meditations.thinkinginspring.aop;import org.springframework.aop.AfterReturningAdvice;import java.lang.reflect.Method;/*** 返回结果时后的处理意见* Created by louis on 2016/4/14.*/
public class TicketServiceAfterReturningAdvice implements AfterReturningAdvice {@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("AFTER_RETURNING：本次服务已结束....");}
}

package org.luanlouis.meditations.thinkinginspring.aop;import org.springframework.aop.ThrowsAdvice;import java.lang.reflect.Method;/*** 抛出异常时的处理意见* Created by louis on 2016/4/14.*/
public class TicketServiceThrowsAdvice implements ThrowsAdvice {public void afterThrowing(Exception ex){System.out.println("AFTER_THROWING....");}public void afterThrowing(Method method, Object[] args, Object target, Exception ex){System.out.println("调用过程出错啦！！！！！");}}

package org.luanlouis.meditations.thinkinginspring.aop;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.aspectj.AspectJAroundAdvice;/**** AroundAdvice* Created by louis on 2016/4/15.*/
public class TicketServiceAroundAdvice implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("AROUND_ADVICE:BEGIN....");Object returnValue = invocation.proceed();System.out.println("AROUND_ADVICE:END.....");return returnValue;}
}

_spring实现原理_《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）

现在，我们来手动使用来创建Proxy对象，并将相应的几种不同的加入这个proxy对应的各个执行阶段中：

package org.luanlouis.meditations.thinkinginspring.aop;import org.aopalliance.aop.Advice;
import org.springframework.aop.framework.ProxyFactoryBean;/*** 通过ProxyFactoryBean 手动创建 代理对象* Created by louis on 2016/4/14.*/
public class App {public static void main(String[] args) throws Exception {//1.针对不同的时期类型，提供不同的AdviceAdvice beforeAdvice = new TicketServiceBeforeAdvice();Advice afterReturningAdvice = new TicketServiceAfterReturningAdvice();Advice aroundAdvice = new TicketServiceAroundAdvice();Advice throwsAdvice = new TicketServiceThrowsAdvice();RailwayStation railwayStation = new RailwayStation();//2.创建ProxyFactoryBean,用以创建指定对象的Proxy对象ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();//3.设置Proxy的接口proxyFactoryBean.setInterfaces(TicketService.class);//4. 设置RealSubjectproxyFactoryBean.setTarget(railwayStation);//5.使用JDK基于接口实现机制的动态代理生成Proxy代理对象，如果想使用CGLIB，需要将这个flag设置成trueproxyFactoryBean.setProxyTargetClass(true);//6. 添加不同的AdviceproxyFactoryBean.addAdvice(afterReturningAdvice);proxyFactoryBean.addAdvice(aroundAdvice);proxyFactoryBean.addAdvice(throwsAdvice);proxyFactoryBean.addAdvice(beforeAdvice);proxyFactoryBean.setProxyTargetClass(false);//7通过ProxyFactoryBean生成Proxy对象TicketService ticketService = (TicketService) proxyFactoryBean.getObject();ticketService.sellTicket();}}

不出意外的话，你会得到如下的输出结果：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_spring实现原理_

你会看到，我们成功地创建了一个通过一个和真实的实例对象创建出了对应的代理对象，并将各个加入到proxy代理对象中。

你会发现，在调用的()之前，成功插入了逻辑，而调用的()之后，逻辑也成功插入了。

也成功包裹了()方法，只不过这个发生的时机有点让人感到迷惑。实际上，这个背后的执行逻辑隐藏了 AOP关于AOP的关于调度最为核心的算法机制，这个将在本文后面详细阐述。

另外，本例中是通过JDK的针对接口的动态代理模式生成代理对象的，具体机制，请看下面关于的介绍。

2、 AOP的核心---

上面我们通过了纯手动使用实现了AOP的功能。现在来分析一下上面的代码：我们为提供了如下信息：

1). Proxy应该感兴趣的列表；

2). 真正的实例对象引用;

3).告诉使用基于接口实现的JDK动态代理机制实现proxy:

4). Proxy应该具备的接口：;

根据这些信息，就能给我们提供我们想要的Proxy对象了！那么，帮我们做了什么？

spring实现原理_《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_

使用工厂Bean模式创建每一个Proxy，对应每一个不同的Class类型，在中都会有一个相对应的. 以下是的类图。

_《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_spring实现原理

如上所示，对于生成Proxy的工厂Bean而言，它要知道对其感兴趣的信息，而这类的信息，被维护到中。可以根据特定的类名和方法名返回对应的，用以表示需要执行的串。

3、基于JDK面向接口的动态代理生成代理对象

类实现了，能够返回Proxy，并且，其自身也实现了角色。也就是说，当我们使用proxy时，我们对proxy对象调用的方法，都最终被转到这个类的()方法中。

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {//省略若干.../** Proxy的配置信息，这里主要提供Advisor列表，并用于返回AdviceChain */private final AdvisedSupport advised;/*** Construct a new JdkDynamicAopProxy for the given AOP configuration.* @param config the AOP configuration as AdvisedSupport object* @throws AopConfigException if the config is invalid. We try to throw an informative* exception in this case, rather than let a mysterious failure happen later.*/public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {Assert.notNull(config, "AdvisedSupport must not be null");if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {throw new AopConfigException("No advisors and no TargetSource specified");}this.advised = config;}@Overridepublic Object getProxy() {return getProxy(ClassUtils.getDefaultClassLoader());}//返回代理实例对象@Overridepublic Object getProxy(ClassLoader classLoader) {if (logger.isDebugEnabled()) {logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());}Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);//这里的InvocationHandler设置成了当前实例对象，即对这个proxy调用的任何方法，都会调用这个类的invoke()方法//这里的invoke方法被调用，动态查找Advice列表，组成ReflectMethodInvocationreturn Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);}/*** 对当前proxy调用其上的任何方法，都将转到这个方法上* Implementation of {@code InvocationHandler.invoke}.* Callers will see exactly the exception thrown by the target,* unless a hook method throws an exception.*/@Overridepublic 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 {if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {// The target does not implement the equals(Object) method itself.return equals(args[0]);}if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {// The target does not implement the hashCode() method itself.return hashCode();}if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&method.getDeclaringClass().isAssignableFrom(Advised.class)) {// Service invocations on ProxyConfig with the proxy config...return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);}Object retVal;if (this.advised.exposeProxy) {// Make invocation available if necessary.oldProxy = AopContext.setCurrentProxy(proxy);setProxyContext = true;}// May be null. Get as late as possible to minimize the time we "own" the target,// in case it comes from a pool.target = targetSource.getTarget();if (target != null) {targetClass = target.getClass();}// Get the interception chain for this method.获取当前调用方法的拦截链List