JDK动态代理：不仅要学会用，更要掌握其原理

程序员文章站 2022-06-26 16:59:13

微信搜索：码农StayUp主页地址：https://gozhuyinglong.github.io源码分享：https://github.com/gozhuyinglong/blog-demosJDK动态代理是指：代理类实例在程序运行时，由JVM根据反射机制动态的生成。也就是说代理类不是用户自己定义的，而是由JVM生成的。由于其原理是通过Java反射机制实现的，所以在学习前，要对反射机制有一定的了解。传送门：Java反射机制：跟着代码学反射下面是本篇讲述内容：1. JDK动态代理的核心类.....

JDK动态代理是指：代理类实例在程序运行时，由JVM根据反射机制动态的生成。也就是说代理类不是用户自己定义的，而是由JVM生成的。

由于其原理是通过Java反射机制实现的，所以在学习前，要对反射机制有一定的了解。传送门：Java反射机制：跟着代码学反射

下面是本篇讲述内容：
JDK动态代理：不仅要学会用，更要掌握其原理

1. JDK动态代理的核心类

JDK动态代理有两大核心类，它们都在Java的反射包下（java.lang.reflect），分别为InvocationHandler接口和Proxy类。

1.1 InvocationHandler接口

也就是说，我们创建的每一个代理实例都要有一个关联的InvocationHandler，并且在调用代理实例的方法时，会被转到InvocationHandler的invoke方法上。

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

该invoke方法的作用是：处理代理实例上的方法调用并返回结果。

其有三个参数，分别为：

proxy：是调用该方法的代理实例。
method：是在代理实例上调用的接口方法对应的Method实例。
args：一个Object数组，是在代理实例上的方法调用中传递的参数值。如果接口方法为无参，则该值为null。

其返回值为：调用代理实例上的方法的返回值。

1.2 Proxy类

代理类具有以下属性：

代理类的名称以 “$Proxy” 开头，后面跟着一个数字序号。
代理类继承了Proxy类。
代理类实现了创建时指定的接口（JDK动态代理是面向接口的）。
每个代理类都有一个公共构造函数，它接受一个参数，即接口InvocationHandler的实现，用于设置代理实例的调用处理器。

Proxy提供了两个静态方法，用于获取代理对象。

1.2.1 getProxyClass

用于获取代理类的Class对象，再通过调用构造函数创建代理实例。

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
        throws IllegalArgumentException

该方法有两个参数：

loader：为类加载器。
intefaces：为接口的Class对象数组。

返回值为动态代理类的Class对象。

1.2.2 newProxyInstance

用于创建一个代理实例。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

该方法有三个参数：

loader：为类加载器。
interfaces：为接口的Class对象数组。
h：指定的调用处理器。

返回值为指定接口的代理类的实例。

1.3 小结

Proxy类主要用来获取动态代理对象，InvocationHandler接口主要用于方法调用的约束与增强。

2. 获取代理实例的代码示例

上一章中已经介绍了获取代理实例的两个静态方法，现在通过代码示例来演示具体实现。

2.1 创建目标接口及其实现类

JDK动态代理是基于接口的，我们创建一个接口及其实现类。

Foo接口：

public interface Foo {

    String ping(String name);

}

Foo接口的实现类RealFoo：

public class RealFoo implements Foo {

    @Override
    public String ping(String name) {
        System.out.println("ping");
        return "pong";
    }

}

2.2 创建一个InvocationHandler

创建一个InvocationHandler接口的实现类MyInvocationHandler。该类的构造方法参数为要代理的目标对象。

invoke方法中的三个参数上面已经介绍过，通过调用method的invoke方法来完成方法的调用。

这里一时看不懂没关系，后面源码解析章节会进行剖析。

public class MyInvocationHandler implements InvocationHandler {

    // 目标对象
    private final Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy - " + proxy.getClass());
        System.out.println("method - " + method);
        System.out.println("args - " + Arrays.toString(args));
        return method.invoke(target, args);
    }
}

2.3 方式一：通过getProxyClass方法获取代理实例

具体实现步骤如下：

根据类加载器和接口数组获取代理类的Class对象
过Class对象的构造器创建一个实例（代理类的实例）
将代理实例强转成目标接口Foo（因为代理类实现了目标接口，所以可以强转）。
最后使用代理进行方法调用。

@Test
public void test1() throws Exception {
    Foo foo = new RealFoo();
    // 根据类加载器和接口数组获取代理类的Class对象
    Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);

    // 通过Class对象的构造器创建一个实例（代理类的实例）
    Foo fooProxy = (Foo) proxyClass.getConstructor(InvocationHandler.class)
        .newInstance(new MyInvocationHandler(foo));

    // 调用 ping 方法，并输出返回值
    String value = fooProxy.ping("杨过");
    System.out.println(value);

}

输出结果：

proxy - class com.sun.proxy.$Proxy4
method - public abstract java.lang.String io.github.gozhuyinglong.proxy.Foo.ping(java.lang.String)
args - [杨过]
ping
pong

通过输出结果可以看出：

代理类的名称是以$Proxy开头的。
方法实例为代理类调用的方法。
参数为代理类调用方法时传的参数。

2.4 方式二：通过newProxyInstance方法获取代理实例

通过这种方法是最简单的，也是推荐使用的，通过该方法可以直接获取代理对象。

注：其实该方法后台实现实际与上面使用getProxyClass方法的过程一样。

@Test
public void test2() {
    Foo foo = new RealFoo();
    // 通过类加载器、接口数组和调用处理器，创建代理类的实例
    Foo fooProxy = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                                new Class[]{Foo.class},
                                                new MyInvocationHandler(foo));
    String value = fooProxy.ping("小龙女");
    System.out.println(value);
}

2.5 通过Lambda表达式简化实现

其实InvocationHander接口也不用创建一个实现类，可以使用Lambad表达式进行简化的实现，如下代码：

@Test
public void test3() {
    Foo foo = new RealFoo();

    Foo fooProxy = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                                new Class[]{Foo.class},
                                                (proxy, method, args) -> method.invoke(foo, args));
    String value = fooProxy.ping("雕兄");
    System.out.println(value);
}

3. 源码解析

3.1 代理类$Proxy是什么样子

JVM为我们自动生成的代理类到底是什么样子的呢？下面我们先来生成一下，再来看里面的构造。

3.1.1 生成$Proxy的.class文件

JVM默认不创建该.class文件，需要增加一个启动参数：
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

在IDEA中点击【Edit Configurations…】，打开 Run/Debug Configurations 配置框。

JDK动态代理：不仅要学会用，更要掌握其原理
将上面启动参数加到【VM options】中，点击【OK】即可。

再次运行代码，会在项目中的【com.sun.proxy】目录中找到这个.class文件，我这里是“$Proxy4.class”
JDK动态代理：不仅要学会用，更要掌握其原理

3.1.2 为什么加上这段启动参数就能生成$Proxy的字节码文件

在Proxy类中有个ProxyClassFactory静态内部类，该类主要作用就是生成静态代理的。

其中有一段代码ProxyGenerator.generateProxyClass用来生成代理类的.class文件。
JDK动态代理：不仅要学会用，更要掌握其原理

其中变量saveGeneratedFiles便是引用了此启动参数的值。将该启动参数配置为true会生成.class文件。
JDK动态代理：不仅要学会用，更要掌握其原理

3.1.3 这个代理类$Proxy到底是什么样子呢

神秘的面纱即将揭露，前面很多未解之迷在这里可以找到答案！

打开这个$Proxy文件，我这里生成的是$Proxy4，下面是内容：

// 该类为final类，其继承了Proxy类，并实现了被代理接口Foo
public final class $Proxy4 extends Proxy implements Foo {

    // 这4个Method实例，代表了本类实现的4个方法
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    // 静态代码块根据反射获取这4个方法的Method实例
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("io.github.gozhuyinglong.proxy.Foo").getMethod("ping");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    // 一个公开的构造函数，参数为指定的 InvocationHandler 
    public $Proxy4(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 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);
        }
    }

    // Foo接口的实现方法，最终调用了 InvocationHandler 中的 invoke 方法
    public final String ping(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 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);
        }
    }
}

通过该文件可以看出：

代理类继承了Proxy类，其主要目的是为了传递InvocationHandler。
代理类实现了被代理的接口Foo，这也是为什么代理类可以直接强转成接口的原因。
有一个公开的构造函数，参数为指定的InvocationHandler，并将参数传递到父类Proxy中。
每一个实现的方法，都会调用InvocationHandler中的invoke方法，并将代理类本身、Method实例、入参三个参数进行传递。这也是为什么调用代理类中的方法时，总会分派到InvocationHandler中的invoke方法的原因。

3.2 代理类是如何创建的

我们从Proxy类为我们提供的两个静态方法开始getProxyClass和newProxyInstance。上面已经介绍了，这两个方法是用来创建代理类及其实例的，下面来看源码。

3.2.1 getProxyClass 和 newProxyInstance方法

JDK动态代理：不仅要学会用，更要掌握其原理

通过上面源码可以看出，这两个方法最终都会调用getProxyClass0方法来生成代理类的Class对象。只不过newProxyInstance方法为我们创建好了代理实例，而getProxyClass方法需要我们自己创建代理实例。

3.2.2 getProxyClass0 方法

下面来看这个统一的入口：getProxyClass0
JDK动态代理：不仅要学会用，更要掌握其原理

从源码和注解可以看出：

代理接口的最多不能超过65535个
会先从缓存中获取代理类，则没有再通过ProxyClassFactory创建代理类。（代理类会被缓存一段时间。）

3.2.3 WeakCache类

这里简单介绍一下WeakCache<K, P, V>类，该类主要是为代理类进行缓存的。获取代理类时，会首先从缓存中获取，若没有会调用ProxyClassFactory类进行创建，创建好后会进行缓存。
JDK动态代理：不仅要学会用，更要掌握其原理

3.2.4 ProxyClassFactory类

ProxyClassFactory是Proxy类的一个静态内部类，该类用于生成代理类。下图是源码的部分内容：

JDK动态代理：不仅要学会用，更要掌握其原理

代理类的名称就是在这里定义的，其前缀是$Proxy，后缀是一个数字。
调用ProxyGenerator.generateProxyClass来生成指定的代理类。
defineClass0方法是一个native方法，负责字节码加载的实现，并返回对应的Class对象。

3.3 原理图

为了便于记录，将代理类的生成过程整理成了一张图。

JDK动态代理：不仅要学会用，更要掌握其原理

源码分享

完整代码请访问我的Github，若对你有帮助，欢迎给个⭐，感谢~~????????????

https://github.com/gozhuyinglong/blog-demos/tree/main/java-source-analysis/src/main/java/io/github/gozhuyinglong/proxy

关于作者

项目	内容
公众号	码农StayUp（ID：AcmenStayUp）
主页	https://gozhuyinglong.github.io
CSDN	https://blog.csdn.net/gozhuyinglong
掘进	https://juejin.cn/user/1239904849494856
Github	https://github.com/gozhuyinglong
Gitee	https://gitee.com/gozhuyinglong

JDK动态代理：不仅要学会用，更要掌握其原理

本文地址：https://blog.csdn.net/gozhuyinglong/article/details/114247819

相关标签： Java源码解析 java 反射动态代理 JDK动态代理

上一篇： Killer XENO Pro二代杀手网卡实测

下一篇：以太网新标准400Gbps

JDK动态代理：不仅要学会用，更要掌握其原理

1. JDK动态代理的核心类

1.1 InvocationHandler接口

1.2 Proxy类

1.2.1 getProxyClass

1.2.2 newProxyInstance

1.3 小结

2. 获取代理实例的代码示例

2.1 创建目标接口及其实现类

2.2 创建一个InvocationHandler

2.3 方式一：通过getProxyClass方法获取代理实例

2.4 方式二：通过newProxyInstance方法获取代理实例

2.5 通过Lambda表达式简化实现

3. 源码解析

3.1 代理类$Proxy是什么样子

3.1.1 生成$Proxy的.class文件

3.1.2 为什么加上这段启动参数就能生成$Proxy的字节码文件

3.1.3 这个代理类$Proxy到底是什么样子呢

3.2 代理类是如何创建的

3.2.1 getProxyClass 和 newProxyInstance方法

3.2.2 getProxyClass0 方法

3.2.3 WeakCache类

3.2.4 ProxyClassFactory类

3.3 原理图

源码分享

推荐阅读

关于作者

JDK动态代理：不仅要学会用，更要掌握其原理

JDK动态代理：不仅要学会用，更要掌握其原理