Spring AOP 源码解析

写在前面

  在分析 Spring AOP 源码之前，如果你对 Spring IOC、依赖注入(DI) 原理不是很清楚，建议您先了解一下：Spring IOC 源码解析、Spring 依赖注入(DI) 源码解析，这样或许会让你的思路更加清晰。

1.什么是Spring AOP ？

  AOP（Aspect Oriented Programming）即：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，是OOP(面向对象编程)的延续。

 AOP是通过动态代理方式，从而实现在不修改源码的情况下，给程序动态的添加功能的一种技术。AOP，最主要的目的就是完成解耦。

2.AOP 名词介绍

  在AOP中，共涉及到1.切面 Aspect、2.连接点 JoinPoint、3.通知 Advice、4.切入点 Pointcut、5.目标对象 Target Object这 5 个名词。

  AOP 名词介绍，这块不做介绍。如果你想要了解，请跳转链接充电：AOP 名词介绍

3.AOP 通知Advice 介绍

  AOP 通知，共有1.前置通知 Before advice、2.后置通知 After advice、3.返回后通知 After return advice、4.抛出异常后通知 After throwing advice、5、环绕通知 Around advice这 5 个。

  AOP 通知相关知识，这块也不做介绍。如果你想要了解，请跳转链接充电：AOP 通知 Advice 介绍

4.AOP 在项目中的使用

  AOP 在项目中的使用，此处分1.xml配置和 2.注解配置 分开进行介绍。AOP 在项目中的使用，我在之前博客中也有介绍，此处不再赘余。请跳转至：Spring AOP 在项目中的使用 去了解。本文主要来分析 Spring AOP 的源码部分。

5.AOP 源码分析从何入手

  在 Spring 中，使用最多的就是工厂方法模式。我们在分析 Spring IOC & DI 依赖注入时，是从 BeanFactory 接口开始，然后通过getBean() 方法入手；

  显然 Spring AOP 的实现，也使用了工厂方法模式。我们在 ProxyFactory 类中，可以通过 getProxy() 方法来获取 Spring 帮我们生成的 Bean 实例的代理对象。

  源码解析阶段，会涉及到动态代理，如过你对 JDK动态代理 和 Cglib 代理还不是很了解，你可以点击如下链接了解：①JDK动态代理（Dynamic Proxy） ②Cglib动态代理（Cglib Proxy）

6.Spring AOP 源码分析时序图  

【】你也可以直接访问链接获取：https://www.processon.com/view/link/5e68bab8e4b018530419f621

Spring AOP源码解析时序图.jpg

7.AOP 源码分析

7.1 JDK 动态代理

1.创建代理对象

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    //调用Proxy.newProxyInstance创建代理对象
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

2.执行 invoke() 方法

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

    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        //eqauls()方法判断
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        }
        //hashCode()方法方法判断
        else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        }
        else if (method.getDeclaringClass() == DecoratingProxy.class) {
            // There is only getDecoratedClass() declared -> dispatch to proxy config.
            return AopProxyUtils.ultimateTargetClass(this.advised);
        }
        //Advised接口或者其父接口中定义的方法,直接反射调用,不应用通知
        else 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;
        }

        //获得目标对象的类
        target = targetSource.getTarget();
        Class targetClass = (target != null ? target.getClass() : null);

        //此处作通知(拦截器链)
        //获取可以应用到此方法上的Interceptor列表(拦截器链，为环绕通知做准备)
        List