详细分析Spring的AOP源码

快来打我* 2024-03-26 21:53 79阅读 0赞

### 前言 ###

本篇将对调用**AOP**动态代理对象时的整个流程进行学习，以探究切面中的类似于前置通知或者后置通知这种通知方法是如何对目标**bean**的目标方法进行增强的。

注：本文均基于**JDK**动态代理。

### 正文 ###

#### 一. AOP动态代理对象结构分析 ####

在上篇的示例工程中，可以看一下测试程序中从容器获取到的**IMyService**的**bean**是什么样子，调试图如下所示。

![format_png][]

可以看到获取出来的**bean**实际为**MyService**的**JDK**动态代理对象，**InvocationHandler**为**JdkDynamicAopProxy**，**JdkDynamicAopProxy**中持有**ProxyFactory**，**ProxyFactory**中持有目标对象和通知链。

#### 二. AOP动态代理对象调用分析 ####

调用动态代理对象的方法时，会调用到**InvocationHandler**的**invoke()** 方法，这里**InvocationHandler**为**JdkDynamicAopProxy**，所以将**JdkDynamicAopProxy**的**invoke()** 方法作为入口开始分析。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
    
        TargetSource targetSource = this.advised.targetSource;
        Object target = null;
    
        try {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // 不会将通知作用在equals()方法，除非目标对象实现的接口中定义了equals()方法
                return equals(args[0]);
            }
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // 不会将通知作用在hashCode()方法，除非目标对象实现的接口中定义了hashCode()方法
                return hashCode();
            }
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // 不会将通知作用于Advised接口或者其父接口中定义的方法
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }
    
            Object retVal;
    
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
    
            // 获取目标对象
            target = targetSource.getTarget();
            // 获取目标对象的Class对象
            Class<?> targetClass = (target != null ? target.getClass() : null);
    
            // 将通知链中能够作用于当前方法的通知组装成拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    
            if (chain.isEmpty()) {
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                // 如果拦截器链是空，那么直接调用目标对象方法
                // AopUtils.invokeJoinpointUsingReflection()最终会调用到method.invoke(target, args)
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // 创建方法调用器MethodInvocation，实际为ReflectiveMethodInvocation
                // 创建ReflectiveMethodInvocation时传入的参数依次为：代理对象，目标对象，目标方法，目标方法参数，

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/67e0158940ed483184cee4f5efffad48.png