Spring AOP源码分析六

上篇文章我们详细分析了下代理工厂ProxyFactory，我们知道在ProxyFactory创建好之后，Spring会为ProxyFactory设置很多核心的属性，其中就包括非常核心的拦截器，这个拦截器包含我们切面中的增强拦截器和普通的拦截器。到这里为止，创建代理的准备工作就准备好了，那么本篇文章就接着往下分析，来看下Spring到底是怎么创建代理的。现在创建代理的准备工作都完成了，那么接下来就会来执行这行代码proxyFactory.getProxy(getProxyClassLoader())，如下图：

我们直接到方法getProxy()方法中看下：

这里先是调用createAopProxy()获取一个对象，然后又调用了这个对象的getProxy()方法，那我们就需要先来看一下这个createAopProxy()返回到到底是哪个对象，我们看下边这行代码：

可以看到，我们发现这里又调用了getAopProxyFactory().createAopProxy(this)，也就是先调用getAopProxyFactory()获得了一个代理工厂，然后又调用了代理工厂的createAopProxy()方法。那getAopProxyFactory()方法获得的到底是哪个代理工厂呢？我们继续来看下getAopProxyFactory()方法到底获取的是什么，我们看下边这行代码：

此时我们发现它返回的就是一个变量，那这个变量是在哪里初始化的呢？我们到这个构造方法中看下，如下图：

可以看到，这个aopProxyFactory变量其实是DefaultAopProxyFactory类的一个实例。我们就知道了我们要找的代理工厂其实是DefaultAopProxyFactory，那接下来就要来调用DefaultAopProxyFactory类的createAopProxy()方法了，我们直接到DefaultAopProxyFactory类中看下这个createAopProxy()方法，如下图：

我们可以看到在这个createAopProxy()方法中有一个极为重要的判断条件，那就是config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)，这里边有两个变量是不是很熟悉？没错，就是当时通过copyFrom()方法为ProxyFactory设置的属性，如下图：

接着在copyFrom()方法中设置了proxyTargetClass属性和optimize属性，我们看下边这块代码：

我们之前不知道proxyTargetClass属性和optimize属性有什么用，现在我们知道这两个属性的作用了，说白了就是在创建代理时，这两个属性会参与选择jdk代理还是cglib代理的判断。那具体又是怎么判断的呢？如果config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)这行代码的三个条件如果都是false，那么就使用jdk代理，如果其中一个为true，那么就会做进一步的判断，不过在看进一步判断之前，我们有必要先来看下这三个条件分别代表什么意思，首先config.isOptimize()表示是否开启了优化策略，这个默认为false，一般不常用，所以我们可以暂时忽略它。接着是config.isProxyTargetClass()，我们在上篇文章，有专门的逻辑来处理这个属性，简单说要不就是我们自己将proxyTargetClass设置为true，要不就是间接指定了BeanDefinition中的preserveTargetClass为true，这两种情况proxyTargetClass都会为true，此时代表是需要基于类进行代理的，而其他情况就是false，代表基于接口代理。最后一个条件是hasNoUserSuppliedProxyInterfaces(config)，它的代码如下：

其实简单说，要不就是目标类没有实现接口 ，要不就是目标类实现了接口且接口类型是SpringProxy，这两种情况只要满足一种就会返回true。现在这行代码config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)的三个条件，我们都分别知道是什么意思了，那我们回头再看下选择代理的这块代码，如下图：

可以看到，当这三个条件都为false时，也就是既没有开启优化策略，也没有设置基于类的代理，最后目标类实现了接口但不是SpringProxy类型的，此时就会使用jdk动态代理，而只要三个条件有一个为true，那么就会走到if分支里边去，但是代码执行到这里的时候，也不能说就使用cglib代理，因为这里还有一个if判断，如下图：

这里会再次判断下，目标类是不是本身就是一个接口或者代理类，那如果目标类本身就是一个接口或者代理类的话，这里还是会使用jdk代理的，其他情况则都会使用cglib代理了。现在我们知道了，在Spring生成代理时，什么时候应该使用jdk代理，什么时候又应该使用cglib代理。
这里我们还是简单总结一下：

• 如果设置了proxyTargetClass为true，也就是设置了基于类进行代理，并且此时目标类本身既不是接口类型也不是代理类时，这个时候就会使用cglib代理。
• 如果没有设置proxyTargetClass，即proxyTargetClass为false，但是此时目标类没有实现接口，此时也会使用cglib代理。
• 如果目标类实现了接口，并且此时没有强制设置使用cglib代理，比如proxyTargetClass为false，这个时候就会使用jdk代理。

我们现在就是既没有开启优化策略，也没有设置基于类的代理，并且目标类实现了接口但不是SpringProxy类型的，也就是说这三个条件全部为false，因此我们这里会使用jdk代理，也就是会执行这行代码，如下图：

我们到 JdkDynamicAopProxy 构造方法中看下：

这里主要就是为JdkDynamicAopProxy中的advised属性进行了赋值，就是将之前构造的ProxyFactory给传了进来，也就是AOP代理的核心配置，里边包含了拦截器等核心属性，然后就直接构造了一个JdkDynamicAopProxy对象出来。接下来就将JdkDynamicAopProxy对象给返回，如下图：

当createAopProxy()方法执行完后，那么下一步就是调用getProxy()方法了，我们看下边这行代码：

此时createAopProxy()方法返回的是JdkDynamicAopProxy类型的对象，那么这里就会来调用JdkDynamicAopProxy类的getProxy()方法。我们直接点进去getProxy()方法，就会看到如下代码：

这里就是使用jdk的Proxy.newProxyInstance()方法创建出来的动态代理对象。我们知道Proxy.newProxyInstance()方法有三个比较核心的参数，分别是类加载器、要实现的接口列表以及回调方法。在这里我们可以看到，先调用completeProxiedInterfaces()方法获取到了要代理的所有接口，然后将这个接口作为入参传了进去。另外我们还看到传给Proxy.newProxyInstance()方法的回调方法竟然是this，说白了就是将当前的JdkDynamicAopProxy对象作为回调方法传了进去。参数都设置完毕后，我们就可以通过Proxy.newProxyInstance()方法拿到一个jdk代理对象了。我们到这个Proxy.newProxyInstance()方法中看下 jdk 是如何创建代理对象的：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
       // 检查一下回调程序是否为空
        Objects.requireNonNull(h);
       // 要实现的接口数组
        final Class<?>[] intfs = interfaces.clone();
        //安全检查
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
         /// 查找或生成指定的代理类，这个主要有两件事情
         // 1、生成代理类字节码 2、将生成的字节码加载到JVM中
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
			// 获取代理类中的构造方法
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            // 使用反射通过构造方法创建代理类对象，这里会将回调函数h传递到代理类中
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

我们可以看到，上边这行代码主要就是调用了getProxyClass0()方法，接着就获取到了一个Class类型的变量cl，那这个cl是什么呢？我们现在还不知道，我们继续往下看：

可以看到，这里直接获取了cl中的构造方法，到这里我们不禁产生一个疑问：“获取cl的构造方法干嘛？难道是要通过这个构造方法来创建一个cl的实例出来吗？”不过这个都是我们自己的猜测，我们还是继续往下看，主要就是跟踪下获取到的这个构造方法cons到底是用来干嘛的这个时候我们就发现了最最重要的一行代码，我们看下边这行代码：

通过上边这行代码，我们发现，这里直接使用反射，通过构造方法创建出了一个对象，并且回调程序h在这里会作为入参传递给这个构造方法，最后将这个创建的对象作为newProxyInstance()方法的结果进行了返回。到这里我们知道了，这个返回的实例就是创建完成的代理对象，那刚才的getProxyClass0()方法返回的Class类型的变量cl，不就是代理类的Class对象吗？那也就是说真正的核心逻辑是在getProxyClass0()方法中，在这个方法中不但生成了代理类，还将生成的代理类加载到了JVM中，这样我们才可以获取到代理类中的构造方法。这个newProxyInstance()方法的代码还是比较清晰的，就是先获取代理类的Class对象，然后再获取构造方法，最后通过构造方法创建了代理类的对象。
最后将创建好的动态代理对象给返回出去了，如下图：

我们现在就分析完了newProxyInstance()方法创建动态代理对象，此时我们就拿到了一个动态代理对象，然后我们就可以通过这个动态代理对象来实现我们的增强逻辑了。

一张图来梳理AOP代理创建流程：