• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

死磕Spring之AOP篇 – 初识JDK、CGLIB两种动态代理

开发技术 开发技术 2个月前 (04-15) 19次浏览

该系列文章是本人在学习 Spring 的过程中总结下来的,里面涉及到相关源码,可能对读者不太友好,请结合我的源码注释 Spring 源码分析 GitHub 地址 进行阅读。

Spring 版本:5.1.14.RELEASE

在开始阅读 Spring AOP 源码之前,需要对 Spring IoC 有一定的了解,可查看我的 《死磕Spring之IoC篇 – 文章导读》 这一系列文章

了解 AOP 相关术语,可先查看 《Spring AOP 常见面试题) 》 这篇文章

该系列其他文章请查看:《死磕 Spring 之 AOP 篇 – 文章导读》

前段时间,我对 Spring IoC 的源码进行了比较全面的学习,并写下了数篇文章进行知识分享。在学习完 Spring IoC 的源码后,也没敢懈怠,趁热打铁,阅读了 Sping AOP 的相关源码,在有了 Spring IoC 的基础之后,你会发现 Spring AOP 的源码并不复杂,嘿嘿 ~

在开始 Spring AOP 源码分析之前,我们先来了解一下其底层 JDK 动态代理和 CGLIB 动态代理两种 AOP 代理的实现。

示例

Echo 服务:

public interface EchoService {

    String echo(String message);
}

默认实现:

public class DefaultEchoService implements EchoService {

    @Override
    public String echo(String message) {
        return "[ECHO] " + message;
    }
}

现在有这么一个需求,当你调用上面的 echo(String) 方法的时候,需要打印出方法的执行时间,那么我们可以怎么做?答案就是通过代理模式,通过代理类为这个对象提供一种代理以控制对这个对象的访问,在代理类中输出方法的执行时间。

静态代理

代理类实现被代理类所实现的接口,同时持有被代理类的引用,新增处理逻辑,当我们调用代理类的方法时候,实际调用被代理类的引用。

代理类:

public class ProxyEchoService implements EchoService {
    /**
     * 被代理对象
     */
    private final EchoService echoService;

    public ProxyEchoService(EchoService echoService) {
        this.echoService = echoService;
    }

    @Override
    public String echo(String message) {
        long startTime = System.currentTimeMillis();
        // 调用被代理对象的方法
        String result = echoService.echo(message);
        long costTime = System.currentTimeMillis() - startTime;
        System.out.println("echo 方法执行的实现:" + costTime + " ms.");
        return result;
    }
}

示例:

public class StaticProxyDemo {

    public static void main(String[] args) {
        // 创建代理类,并传入被代理对象,也就是 DefaultEchoService
        EchoService echoService = new ProxyEchoService(new DefaultEchoService());
        echoService.echo("Hello,World");
    }
}

控制台会输出以下内容:

echo 方法执行的实现:0 ms.

得到的结论:

静态代理就是通过实现被代理对象所实现的接口,内部保存了被代理对象,在实现的方法中对处理逻辑进行增强,实际的方法执行调用了被代理对象的方法。可以看到静态代理比较简洁直观,但是在复杂的场景下,需要为每个目标对象创建一个代理类,不易于维护,我们更加注重的应该是业务开发,对于这一层增强处理应该抽取出来。

JDK 动态代理

基于接口代理,通过反射机制生成一个实现代理接口的类,在调用具体方法时会调用 InvokeHandler 来处理。

示例

public class JdkDynamicProxyDemo {

    public static void main(String[] args) {
        // 当前线程的类加载器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // $Proxy0
        Object proxy = Proxy.newProxyInstance(classLoader, new Class[]{EchoService.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (EchoService.class.isAssignableFrom(method.getDeclaringClass())) {
                    // 被代理对象
                    EchoService echoService = new DefaultEchoService();
                    long startTime = System.currentTimeMillis();
                    String result = echoService.echo((String) args[0]);
                    long costTime = System.currentTimeMillis() - startTime;
                    System.out.println("echo 方法执行的实现:" + costTime + " ms.");
                    return result;
                }
                return null;
            }
        });
        EchoService echoService = (EchoService) proxy;
        echoService.echo("Hello,World");
    }
}

控制台会输出以下内容:

echo 方法执行的实现:0 ms.

分析

借助 JDK 的 java.lang.reflect.Proxy 来创建代理对象,调用 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法可以创建一个代理对象,方法的三个入参分别是:

  • ClassLoader loader:用于加载代理对象的 Class 类加载器
  • Class<?>[] interfaces:代理对象需要实现的接口
  • InvocationHandler h:代理对象的处理器

新生成的代理对象的 Class 对象会继承 Proxy,且实现所有的入参 interfaces 中的接口,在实现的方法中实际是调用入参 InvocationHandlerinvoke(..) 方法。

上面可以看到 InvocationHandler 是直接在入参中创建的,在 invoke(..) 方法中拦截 EchoService 的方法。这里的被代理对象是在其内部创建的,实际上我们可以在创建 InvocationHandler 实现类的时候进行设置,这里为了方便直接在内部创建。

新生成的 Class 对象

JDK 动态代理在 JVM 运行时会新生成一个代理对象,那么我们先来看看这个代理对象的字节码,通过添加下面的 JVM 参数可以保存生成的代理对象的 .class 文件

# jdk8及以前版本
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
# jdk8+
-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true

在同工程目录下你会发现有一个 .class 文件,如下:

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.geekbang.thinking.in.spring.aop.overview.EchoService;

public final class $Proxy0 extends Proxy implements EchoService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String echo(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.EchoService").getMethod("echo", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从这个代理对象中你可以看到,它继承了 java.lang.reflect.Proxy 这个类,并实现了 EchoService 接口。在实现的 echo(String) 方法中,实际上调用的就是父类 Proxy 中的 InvocationHandler 的 incoke(..) 方法,这个 InvocationHandler 就是创建代理对象时传入的参数

Proxy 底层原理

newProxyInstance 方法

JDK 动态代理是通过 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法创建的代理对象,那我们来看看这个方法会做哪些事情

// java.lang.reflect.Proxy.java
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    // InvocationHandler 不能为空
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    // 获取代理对象的 Class 对象(生成一个代理类)
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        if (sm != null) {
            // 安全检测,检测是否能够创建对象
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        // 获取代理类的构造器(入参为 InvocationHandler)
        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;
                }
            });
        }
        // 通过构造器创建一个实例对象,入参是 InvocationHandler 的实现类
        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);
    }
}

这个方法的逻辑不复杂,获取到代理类的 Class 对象,然后通过构造器创建一个代理对象,构造器的入参就是 InvocationHandler 的实现类。因为代理类会继承 Proxy这个类,在 Proxy 中就有一个 Proxy(InvocationHandler h) 构造方法,所以可以获取到对应的构造器。其中获取代理对象的 Class 对象(生成一个代理类)调用 getProxyClass0(ClassLoader loader, Class<?>... interfaces) 方法。

getProxyClass0 方法
// java.lang.reflect.Proxy.java

/**
 * a cache of proxy classes
 */
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    // 接口数量不能大于 65535
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    // 
    return proxyClassCache.get(loader, interfaces);
}

先尝试从 proxyClassCache 缓存中获取对应的代理类,如果不存在则通过 ProxyClassFactory 函数创建一个代理类

ProxyClassFactory 代理类工厂
// java.lang.reflect.Proxy.java
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy";

    // next number to use for generation of unique proxy class names
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        /*
         * 遍历需要实现的接口,进行校验
         */
        for (Class<?> intf : interfaces) {
            // 校验该接口是在存在这个 ClassLoader 中
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            // 校验是否真的是接口(因为入参也可以不传接口)
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            
            // 校验是否出现相同的接口(因为入参也可以传相同的接口)
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * 遍历需要实现的接口,判断是否存在非 `public` 的接口
         * 如果存在,则记录下来,并记录所在的包名
         * 如果存在非 `public` 的接口,且还存在其他包路径下的接口,则抛出异常
         */
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }

        // 如果不存在非 `public` 的接口,则代理类的名称前缀为 `com.sun.proxy.`
        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        // 生成一个代理类的名称,`com.sun.proxy.$Proxy` + 唯一数字(从 0 开始递增)
        // 对于非 `public` 的接口,这里的名前缀就取原接口包名了,因为不是 `public` 修饰需要保证可访问
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        // 根据代理类的名称、需要实现的接口以及修饰符生成一个字节数组
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            // 根据代理类对应的字节数组创建一个 Class 对象
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

创建代理类的过程如下:

  1. 遍历需要实现的接口,进行校验;
    • 校验该接口是在存在这个 ClassLoader 中
    • 校验是否真的是接口(因为入参也可以不传接口)
    • 校验是否出现相同的接口(因为入参也可以传相同的接口)
  2. 遍历需要实现的接口,判断是否存在非 public 的接口,该步骤和生成的代理类的名称有关;
    • 如果存在,则记录下来,并记录所在的包名
    • 如果存在非 public 的接口,且还存在其他包路径下的接口,则抛出异常
  3. 如果不存在非 public 的接口,则代理类的名称前缀为 com.sun.proxy.
  4. 生成一个代理类的名称,com.sun.proxy.$Proxy + 唯一数字(从 0 开始递增)
    • 对于非 public 的接口,这里的名前缀就取原接口包名了,因为不是 public 修饰需要保证可访问
  5. 根据代理类的名称、需要实现的接口以及修饰符生成一个字节数组
  6. 根据第 5 步生成的代理类对应的字节数组创建一个 Class 对象

可以看到就是根据入参中的接口创建一个 Class 对象,实现这些接口,然后创建一个实例对象

为什么 JDK 动态代理只能基于接口代理,不能基于类代理?

在该过程也可以看到,对于入参中的 interfaces 如果存在非接口,那么会抛出异常;且从生成的代理对象中看到会继承 Proxy 这个类,在 Java 中类只能是单继承关系,无法再继承一个代理类,所以只能基于接口代理。

在代理对象中,入参 InvocationHandler h 实际放入了父类 Proxy 中,为什么不直接声明到这个代理对象里面呢?

我觉得代理类既然是 JDK 动态生成的,那么 JDK 就需要识别出哪些类是生成的代理类,哪些是非代理类,或者说 JDK 需要对代理类做统一的处理,这时如果没有一个统一的类 Proxy 来进行引用根本无法处理。当然,还有其他的原因,暂且不知道。

CGLIB 动态代理

JDK 动态代理的目标对象必须是一个接口,在我们日常生活中,无法避免开发人员不写接口直接写类,或者根本不需要接口,直接用类进行表达。这个时候我们就需要通过一些字节码提升的手段,来帮助做这个事情,在运行时,非编译时,来创建新的 Class 对象,这种方式称之为字节码提升。在 Spring 内部有两个字节码提升的框架,ASM(过于底层,直接操作字节码)和 CGLIB(相对于前者更加简便)。

CGLIB 动态代理则是基于类代理(字节码提升),通过 ASM(Java 字节码的操作和分析框架)将被代理类的 class 文件加载进来,通过修改其字节码生成子类来处理。

示例

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibDynamicProxyDemo {

    public static void main(String[] args) {
        // 创建 CGLIB 增强对象
        Enhancer enhancer = new Enhancer();
        // 指定父类,也就是被代理的类
        Class<?> superClass = DefaultEchoService.class;
        enhancer.setSuperclass(superClass);
        // 指定回调接口(拦截器)
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object source, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                long startTime = System.currentTimeMillis();
                Object result = methodProxy.invokeSuper(source, args);
                long costTime = System.currentTimeMillis() - startTime;
                System.out.println("[CGLIB 字节码提升] echo 方法执行的实现:" + costTime + " ms.");
                return result;
            }
        });

        // 创建代理对象
        EchoService echoService = (EchoService) enhancer.create();
        // 输出执行结果
        System.out.println(echoService.echo("Hello,World"));
    }
}

控制台会输出以下内容:

[CGLIB 字节码提升] echo 方法执行的实现:19 ms.
[ECHO] Hello,World

分析

需要借助于 CGLIB 的 org.springframework.cglib.proxy.Enhancer 类来创建代理对象,设置以下几个属性:

  • Class<?> superClass:被代理的类
  • Callback callback:回调接口

新生成的代理对象的 Class 对象会继承 superClass 被代理的类,在重写的方法中会调用 callback 回调接口(方法拦截器)进行处理。

上面可以看到 Callback 是直接创建的,在 intercept(..) 方法中拦截 DefaultEchoService 的方法。因为 MethodInterceptor 继承了 Callback 回调接口,所以这里传入一个 MethodInterceptor 方法拦截器是没问题的。

注意,如果你想设置一个 Callback[] 数组去处理不同的方法,那么需要设置一个 CallbackFilter 筛选器,用于选择这个方法使用数组中的那个 Callback 去处理

新生成的 Class 对象

CGLIB 动态代理在 JVM 运行时会新生成一个代理类,这个代理对象继承了目标类,也就是创建了一个目标类的子类,从而字节码得到提升。那么我们可以看看这个代理类的字节码,通过添加下面的 JVM 参数可以保存生成的代理类的 .class 文件

-Dcglib.debugLocation=${class文件 保存路径}

在指定的保存路径下你会发现存在这么一个 .class 文件,如下:

package org.geekbang.thinking.in.spring.aop.overview;

import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class DefaultEchoService$$EnhancerByCGLIB$$c868af31 extends DefaultEchoService implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$echo$0$Method;
    private static final MethodProxy CGLIB$echo$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.DefaultEchoService$$EnhancerByCGLIB$$c868af31");
        Class var1;
        CGLIB$echo$0$Method = ReflectUtils.findMethods(new String[]{"echo", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.DefaultEchoService")).getDeclaredMethods())[0];
        CGLIB$echo$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "echo", "CGLIB$echo$0");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
    }

    final String CGLIB$echo$0(String var1) {
        return super.echo(var1);
    }

    public final String echo(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$echo$0$Method, new Object[]{var1}, CGLIB$echo$0$Proxy) : super.echo(var1);
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1042135322:
            if (var10000.equals("echo(Ljava/lang/String;)Ljava/lang/String;")) {
                return CGLIB$echo$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public DefaultEchoService$$EnhancerByCGLIB$$c868af31() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var1 = (DefaultEchoService$$EnhancerByCGLIB$$c868af31)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

你会看到这个代理类继承了 DefaultEchoService 目标类,在重写的 echo(String) 方法中会调用 Callback 的 intercept(..) 拦截方法进行处理,由于生成的代理类不是那么容易理解,这里就不做分析了,有一个大致的思路就可以,感兴趣的可以研究研究。

Enhancer 底层原理

create() 方法

CGLIB 动态代理可以通过 Enhancer.create() 方法进行字节码提升,该过程比较复杂,不易看懂,我们简单看看做了什么事情

// org.springframework.cglib.proxy.Enhancer.java

public Object create() {
    this.classOnly = false;
    this.argumentTypes = null;
    return this.createHelper();
}

private Object createHelper() {
    // Callback 的校验
    this.preValidate();
    // 创建一个 EnhancerKey 对象,主要设置代理类名称、和 Cllback 的类
    Object key = KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null,
                                         ReflectUtils.getNames(this.interfaces), 
                                         this.filter == ALL_ZERO ? null : new WeakCacheKey(this.filter), 
                                         this.callbackTypes, 
                                         this.useFactory, 
                                         this.interceptDuringConstruction, 
                                         this.serialVersionUID);
    this.currentKey = key;
    // 创建一个代理对象(代理类的子类)
    Object result = super.create(key);
    return result;
}
preValidate 方法
// org.springframework.cglib.proxy.Enhancer.java

private static final CallbackFilter ALL_ZERO = new CallbackFilter() {
    public int accept(Method method) {
        return 0;
    }
};

private void preValidate() {
    // 设置 Callback 的类型
    if (this.callbackTypes == null) {
        this.callbackTypes = CallbackInfo.determineTypes(this.callbacks, false);
        this.validateCallbackTypes = true;
    }

    // 如果 Callback 筛选器为空,则设置为取第一个
    // `filter` 用于筛选拦截方法所对应的 Callback
    if (this.filter == null) {
        if (this.callbackTypes.length > 1) {
            throw new IllegalStateException("Multiple callback types possible but no filter specified");
        }

        this.filter = ALL_ZERO;
    }
}
create(Object) 方法
protected Object create(Object key) {
    try {
        // 获取类加载器
        ClassLoader loader = this.getClassLoader();
        Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> cache = CACHE;
        // 获取 ClassLoaderData 类加载器数据
        AbstractClassGenerator.ClassLoaderData data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
        if (data == null) {
            Class var5 = AbstractClassGenerator.class;
            synchronized(AbstractClassGenerator.class) {
                cache = CACHE;
                data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
                if (data == null) {
                    Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> newCache = new WeakHashMap(cache);
                    data = new AbstractClassGenerator.ClassLoaderData(loader);
                    newCache.put(loader, data);
                    CACHE = newCache;
                }
            }
        }

        this.key = key;
        // 通过类加载器根据 `key` 创建一个 Class 对象(例如 FastClassByCGLIB)
        Object obj = data.get(this, this.getUseCache());
        // 通过 Class 对象创建一个代理对象
        return obj instanceof Class ? this.firstInstance((Class)obj) : this.nextInstance(obj);
    } catch (Error | RuntimeException var9) {
        throw var9;
    } catch (Exception var10) {
        throw new CodeGenerationException(var10);
    }
}

整个过程比较复杂,上面没有深入分析,因为笔者实在是看不懂~😢,可以先理解为创建一个目标类的子类😈

总结

本文对 JDK 动态代理和 CGLIB 动态代理进行了浅显的分析,可以得出以下结论:

  • 静态代理通过实现被代理类所实现的接口,内部保存被代理类的引用,在实现的方法中对处理逻辑进行增强,真正的方法执行调用被代理对象的方法。静态代理比较简洁直观,不过每个目标对象都需要创建一个代理类,在复杂的场景下需要创建大量的代理类,不易于维护,也不易于扩展,我们更加注重的应该是业务开发,对于这一层增强处理应该抽取出来。
  • JDK 动态代理基于接口代理,在 JVM 运行时通过反射机制生成一个实现代理接口的类,在调用具体方法时会调用 InvokeHandler 来进行处理。
  • CGLIB 动态代理基于类代理(字节码提升),通过 ASM(Java 字节码的操作和分析框架)将被代理类的 class 文件加载进来,通过修改其字节码生成一个子类来处理。

为什么 JDK 动态代理只能基于接口代理,不能基于类代理?

JDK 动态代理通过 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 创建代理对象,对于入参中的 interfaces 如果存在非接口,会抛出异常;且从生成的代理对象中看到代理对象会继承 Proxy 这个类,在 Java 中类只能是单继承关系,无法再继承一个代理类,所以只能基于接口代理。


程序员灯塔
转载请注明原文链接:死磕Spring之AOP篇 – 初识JDK、CGLIB两种动态代理
喜欢 (0)