大厂面试必备系列：一文彻底搞懂 Jdk 动态代理

原创 已于 2024-07-09 22:59:11 修改 · 628 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#面试 #java #职场和发展
于 2024-07-09 22:58:56 首次发布

👆🏻👆🏻👆🏻关注博主，让你的代码变得更加优雅。

前言

大家在面试中经常被问到 Cglib 和 JDK动态代理有啥区别？ 然后每次回答都是 Jdk 动态代理是实现接口。

这个回答当然是对的，但是太敷衍了，没得加分，今天我带大家深入了解下，带你搞清楚到时实现了啥东西。

最佳实践

直接上案例

案例地址： https://github.com/zhuangjiaju/easytools/blob/main/easytools-test/src/test/java/com/github/zhuangjiaju/easytools/test/demo/jdk/JdkProxyTest.java

建议先读 “大厂面试必备系列：一文彻底搞懂 Cglib 代理”
,可以打开 https://github.com/zhuangjiaju/easytools 找到案例

最简单的jdk动态代理案例

jdk动态代理核心是根据接口生成一个代理类，然后访问接口的时候先调用 InvocationHandler ,然后再调用具体实现类。

假设我们现在要实现：调用setName 都改成 name+" 你真棒！！！"

这里和 Cglib 不同，必须有接口 不然无法使用：

/**
 * jdk动态代理的接口
 * 这里和 Cglib 不同，必须有接口 不然无法使用
 *
 * @author Jiaju Zhuang
 */
public interface JdkProxyDemoInterfaceDTO {

    String getName();

    void setName(String name);
}

具体实现类很简单：


/**
 * jdk动态代理的案例
 *
 * @author Jiaju Zhuang
 */
public class JdkProxyDemoDTO implements JdkProxyDemoInterfaceDTO {
    /**
     * 名字
     */
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

最后是实现代码：

     /**
 * 最简单的jdk动态代理案例
 * 调用setName 都改成 name+" 你真棒！！！"
 */
@Test
public void simple() throws Exception {
    // 我们需求是将 jdkProxyDemo.name 设置成 "JiaJu Zhuang"
    // 先新建一个对象
    Object object = new JdkProxyDemoDTO();
    JdkProxyDemoInterfaceDTO proxyInstance = (JdkProxyDemoInterfaceDTO)Proxy.newProxyInstance(
        // 指定用上面类加载器
        JdkProxyTest.class.getClassLoader(),
        // 指定要代理成上面接口
        new Class<?>[] {JdkProxyDemoInterfaceDTO.class},
        // 指定InvocationHandler，用于代理后的回调
        (proxy, method, args) -> {
            // 判断setName方法且是String
            if (method.getName().equals("setName") && args[0] != null && args[0] instanceof String) {
                String name = (String)args[0];
                // 修改参数
                args[0] = name + " 你真棒！！！";
            }
            return method.invoke(object, args);
        });

    proxyInstance.setName("JiaJu Zhuang");
    log.info("输出结果:{},{}", proxyInstance.getName(), proxyInstance.getClass());
    Assertions.assertEquals("JiaJu Zhuang 你真棒！！！", proxyInstance.getName());
}

是不是好好奇？为什么调用 proxyInstance.setName 会回调到 InvocationHandler 的代码呢？

错误的查看生成后的源码

我们通过System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true"); 来设置输出代理类，无法指定位置，生成在工程目录下。

    /**
 * 查看生成后的源码
 */
@Test
public void showClass() throws Exception {
    // 只需要设置 jdk.proxy.ProxyGenerator.saveGeneratedFiles
    // 这里设置了没用？
    System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");

    // 先新建一个对象
    Object object = new JdkProxyDemoDTO();
    JdkProxyDemoInterfaceDTO proxyInstance = (JdkProxyDemoInterfaceDTO)Proxy.newProxyInstance(
        // 指定用上面类加载器
        JdkProxyTest.class.getClassLoader(),
        // 指定要代理成上面接口
        new Class<?>[] {JdkProxyDemoInterfaceDTO.class},
        // 指定InvocationHandler，用于代理后的回调
        (proxy, method, args) -> {
            // 判断setName方法且是String
            if (method.getName().equals("setName") && args[0] != null && args[0] instanceof String) {
                String name = (String)args[0];
                // 修改参数
                args[0] = name + " 你真棒！！！";
            }
            return method.invoke(object, args);
        });

    proxyInstance.setName("JiaJu Zhuang");
    log.info("输出结果:{},{}", proxyInstance.getName(), proxyInstance.getClass());
    Assertions.assertEquals("JiaJu Zhuang 你真棒！！！", proxyInstance.getName());
}

我们会发现压根没有输出，只能跟进源码java.lang.reflect.ProxyGenerator ,关键代码：

final class ProxyGenerator extends ClassWriter {
   

    /**
     * 这里是成员变量 所以第一次加载class的时候就会去读去配置
     */
    @SuppressWarnings("removal")
    private static final boolean saveGeneratedFiles =
        java.security.AccessController.doPrivileged(
            new GetBooleanAction(
                "jdk.proxy.ProxyGenerator.saveGeneratedFiles"));

    static byte[] generateProxyClass(ClassLoader loader,
        final String name,
        List<Class<?>> interfaces,
        int accessFlags) {
        ProxyGenerator gen = new ProxyGenerator(loader, name, interfaces, accessFlags);
        final byte[] classFile = gen.generateClassFile();

        // 判断是否需要输出class 需要则输出
        if (saveGeneratedFiles) {
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction<Void>() {
                    public Void run() {
                        try {
                            int i = name.lastIndexOf('.');
                            Path path;
                            if (i > 0) {
                                Path dir = Path.of(dotToSlash(name.substring(0, i)));
                                Files.createDirectories(dir);
                                path = dir.resolve(name.substring(i + 1) + ".class");
                            } else {
                                path = Path.of(name + ".class");
                            }
                            Files.write(path, classFile);
                            return null;
                        } catch (IOException e) {
                            throw new InternalError(
                                "I/O exception saving generated file: " + e);
                        }
                    }
                });
        }

        return classFile;
    }
}

debug后发现 saveGeneratedFiles 方法在我们 调用System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true"); 之前就已经设置好了。
原因是：junit 也用了jdk 代理，然后去初始化 saveGeneratedFiles 我们压根没有设置变量，所以一直无法打印。

正确的查看生成后的源码

最简单的就是不要使用junit了 直接写main函数。

 /**
 * 查看生成后的源码
 */
public static void main(String[] args1) {
    // 只需要设置 jdk.proxy.ProxyGenerator.saveGeneratedFiles 即可
    // 这里为啥不用junit了？ 原因是junit 调用我们 System.setProperty 之前已经用来 动态代理，然后已经读取了 配置 我们设置也没用了
    System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
    // 先新建一个对象
    Object object = new JdkProxyDemoDTO();
    JdkProxyDemoInterfaceDTO proxyInstance = (JdkProxyDemoInterfaceDTO)Proxy.newProxyInstance(
        // 指定用上面类加载器
        JdkProxyTest.class.getClassLoader(),
        // 指定要代理成上面接口
        new Class<?>[] {JdkProxyDemoInterfaceDTO.class},
        // 指定InvocationHandler，用于代理后的回调
        (proxy, method, args) -> {
            // 判断setName方法且是String
            if (method.getName().equals("setName") && args[0] != null && args[0] instanceof String) {
                String name = (String)args[0];
                // 修改参数
                args[0] = name + " 你真棒！！！";
            }
            return method.invoke(object, args);
        });

    proxyInstance.setName("JiaJu Zhuang");
    log.info("输出结果:{},{}", proxyInstance.getName(), proxyInstance.getClass());
    Assertions.assertEquals("JiaJu Zhuang 你真棒！！！", proxyInstance.getName());
}

终于在项目的根目录 jdk/proxy1.$Proxy0 找到了代理类 ,他继承了 Proxy 类，并实现了我们的接口 JdkProxyDemoInterfaceDTO。


public final class $Proxy0 extends Proxy implements JdkProxyDemoInterfaceDTO {
    private static final Method m0;
    private static final Method m1;
    private static final Method m2;
    private static final Method m3;
    // 对象setName方法
    private static final Method m4;

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

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

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

    public final String toString() {
        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 String getName() {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    // 这里就是我们调用的方法
    public final void setName(String var1) {
        try {
            // 直接调用父类的 InvocationHandler的invoke方法
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        ClassLoader var0 = $Proxy0.class.getClassLoader();

        try {
            m0 = Class.forName("java.lang.Object", false, var0).getMethod("hashCode");
            m1 = Class.forName("java.lang.Object", false, var0).getMethod("equals", Class.forName("java.lang.Object", false, var0));
            m2 = Class.forName("java.lang.Object", false, var0).getMethod("toString");
            m3 = Class.forName("com.github.zhuangjiaju.easytools.test.demo.jdk.JdkProxyDemoInterfaceDTO", false, var0).getMethod("getName");
            // m4 就是我们对应的 Method
            m4 = Class.forName("com.github.zhuangjiaju.easytools.test.demo.jdk.JdkProxyDemoInterfaceDTO", false, var0).getMethod("setName", Class.forName("java.lang.String", false, var0));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

    private static MethodHandles.Lookup proxyClassLookup(MethodHandles.Lookup var0) throws IllegalAccessException {
        if (var0.lookupClass() == Proxy.class && var0.hasFullPrivilegeAccess()) {
            return MethodHandles.lookup();
        } else {
            throw new IllegalAccessException(var0.toString());
        }
    }
}

是不是很简单？实际上他初始化了setName 的 Method 为 m4 ，然后调用 setName 的时候直接调用 InvocationHandler.invoke 就可以，然后就到我们自己写的InvocationHandler来了。

总结

通过这篇文章给大家普及了 Jdk 动态代理的基础知识，让 Jdk 动态代理变的不在神秘，大家有时间就去动手试试吧，试过才是自己的。

写在最后

给大家推荐一个非常完整的Java项目搭建的最佳实践,也是本文的源码出处，由大厂程序员&EasyExcel作者维护，地址：https://github.com/zhuangjiaju/easytools

面试官：你说你懂动态代理，那你知道为什么JDK中的代理类都要继承Proxy吗？
12-21
之前我已经写过了关于动态代理的两篇文章，本来以为这块应该没啥问题，没想到今天又被难住了… 太难了！！！ 之前文章的链接： 动态代理学习（一）自己动手模拟JDK动态代理、 动态代理学习（二）JDK动态代理源码分析 在动态代理学习（二）JDK动态代理源码分析中我已经讲JDK底层生成的字节码文件反编译成了java代码，如下： public final class proxy extends Proxy implements MyService { private static Method m1; private static Method m4; private stati
经典面试题 之 JDK动态代理和CGLIB动态代理
weixin_69413377的博客
08-02 1208
jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。......
JDK 动态代理
weixin_43232662的博客
09-13 333
备注：来源声明 一、什么是代理 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 代理模式UML图： 结构示意图： 为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理
JDK动态代理源码解析
西岭千秋雪的博客
11-17 1671
本篇从源码的角度，对JDK动态代理的实现，工作原理做简要分析。
Java基础------真实大厂面试题汇总（含答案）
drnrrwfs的博客
08-01 667
什么是序列化和反序列化？Java序列化是指把Java对象保存为二进制字节码的过程，Java反序列化是指把二进制码重新转换成Java对象的过程序列化的底层怎么实现的？其实就是利用了java的IO流来进行实现的，//这个是一个需要序列化的实体对象//这是为了把实体对象写到输出流中，然后保存到D盘的一个路径下}...
关于动态代理在面试中的一些问题
weixin_53700782的博客
11-10 517
关于动态代理在面试中的一些问题
大厂面试必备系列：一文彻底搞懂 Cglib 代理
一起成为更好的Java工程师
07-08 528
大家在面试中经常被问到 Cglib 和 JDK动态代理有啥区别？然后每次回答都是 Cglib 通过创建目标类的子类来实现代理。这个回答当然是对的，但是太敷衍了，没得加分，今天我带大家深入了解下。通过这篇文章大家是不是对吹的神乎其技的 Cglib 有了新的理解，实际上他比大家想象的容易非常多，只是大家没有时间去实践一下，大家去动手试试吧，试过才是自己的。
2024年最新Java大厂面试笔试题分享，通往BAT必备法宝
2401_83330193的博客
03-18 1073
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
[Java 面试] 面试被问Java的动态代理机制，能说说吗_应聘java实习生时会让写动态代理吗(1)
ghfgjfg679的博客
04-30 610
说句实话，如果一个打工人不想提升自己，那便没有工作的意义，毕竟大家也没有到养老的年龄。当你的技术在一步步贴近阿里p7水平的时候，毫无疑问你的薪资肯定会涨，同时你能学到更多更深的技术，交结到更厉害的大牛。推荐一份Java架构之路必备的学习笔记，内容相当全面！！！成年人的世界没有容易二字，前段时间刷抖音看到一个程序员连着加班两星期到半夜2点的视频。在这个行业若想要拿高薪除了提高硬实力别无他法。你知道吗？现在有的应届生实习薪资都已经赶超开发5年的程序员了，实习薪资26K，30K，你没有紧迫感吗？
20位大厂面试官推荐的《Java面试八股文》到底有多牛？
m0_68850571的博客
07-31 543
很多同学会问Java面试八股文有必要背吗？我的回答是很有必要。你可以讨厌这种模式，但你一定要去背，因为不背你就进不了大厂。国内的互联网面试，恐怕是现存的、最接近科举考试的制度。而且，我国的八股文确实是独树一帜。以美国为例，北美工程师面试比较重视算法（Coding），近几年也会加入Design轮（系统设计和面向对象设计OOD）和BQ轮（Behavioralquestion，行为面试问题）。那么为什么国内面试不采取这样的考察方式呢？......
动态代理总结，面试你要知道的都在这里，硬核干货无废话
守夜人爱吃兔子的博客
05-19 454
前言 这篇文章总结你需要回答的知识点，全程少废话，怼干货，文章较长，可以点赞在看，喜欢这种文章的话，我之后也会一直分享的，硬核文章也会定期分享！ 代理模式 代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能，就好比在租房的时候，有的人会通过房东直租，有的人会通过中介租房。 那这两种情况哪种比较方便呢？当然是通过中介更加方便。这里的中介就相当于代理，用户通...
面试必备技能：JDK动态代理给Spring事务埋下的坑！
热门推荐
徐刘根的博客
01-10 1万+
一、场景分析 最近做项目遇到了一个很奇怪的问题，大致的业务场景是这样的：我们首先设定两个事务，事务parent和事务child，在Controller里边同时调用这两个方法，示例代码如下： 1、场景A： @RestController @RequestMapping(value = "/test") public class OrderController { @Autowir...
Java 面试必考题：动态代理
m0_67400973的博客
05-17 1095
前天下午 2 点，坐标西二旗，某一线互联网大厂，面试官问：请讲讲什么是代理？什么是动态代理？什么是 ASM？面对连珠炮的问题，我闯了两关，但没能通关，只能回去等通知了。 回去不吃饭不睡觉，不断总结 JDK 的动态代理模式，从一知半解到茅塞顿开，才有了这次的 GitChat： 什么是代理模式 写一个静态代理代理 静态代理的缺点 JDK 动态代理的实现 JDK 动态代理的缺点 CGLIB 动态代理的实现 CGLIB 动态代理的缺点 Spring AOP 代理的实现 阅读全文: http://gitbook.
不会这些JDK动态代理的面试点 金九银十想面BAT？
ruanHbac的博客
07-13 181
一、什么是代理 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 代理模式UML图： 结构示意图： 为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态
Spring强制使用CGLIB代理事务
WWWTYB的专栏
06-30 9941
JDK的动态代理：主要是针对实现了接口的类生成代理 CGLIB：是针对类生成代理，针对指定的类生成一个子类，覆盖里面的方法，所以指定的类不能是final包括方法. 实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的，性能比JDK强。
java动态代理---面试
qq_37272886的博客
06-28 1082
代理模式： 代理模式在Java中特别常见，如spring AOP功能就是用代理来实现的。代理模式作用是：在不修改被代理对象功能的基础上，通过对代理类进行扩展，进行一些功能上的附加与增强。 一般使用代理模式我们需要先定义一个接口，静态代理只是一种简单的java代码功能扩展。而动态代理利用了反射机制，使用更简单，但背后逻辑…先说明一点，动态代理代理的是接口，而不是类，Proxy类产生的代理对象是Proxy的一个实例，这个实例实现了我们定义的接口 一、静态代理 面向接口的编程，代理类与真实类继承自同一个接口（
动态代理面试-java
qq_42953529的博客
07-18 2827
1）、JDK和CGLib的区别 JDK动态代理只能对实现了接口的类生成代理，而不能针对类 CGLib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法（继承） 2）、Spring在选择用JDK还是CGLib的依据 当Bean实现接口时，Spring就会用JDK的动态代理 当Bean没有实现接口时，Spring使用CGLib来实现 可以强制使用CGLib（在Spring配置...
Java静态代理、动态代理（JDK代理、CGLIB代理）常见面试题
qq_42390636的博客
03-27 2073
小结： 静态代理不灵活，静态代理类似模板方法设计模式。 动态代理灵活、方便。每个框架都会使用到，例如，spring中的AOP。默认为JDK实现方式，也可选择CGLIB实现方式。 JDK动态代理只能代理实现接口的类或者直接代理接口。限制：必须要有接口。思考：Spring中AOP是如何实现的？（改天会作为一个专题研究一下） CGLIB动态代理即可代理接口也可代理类。 JDK直接代理类会出现java.lang.IllegalArgumentException: xxx is not an interfa
五十二：JDK动态代理和CGLIB动态代理
qq_38022739的博客
09-17 2947
JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP 2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP 3、如果目标对象没有实现了接口...
STL set与map底层精讲，红黑树适配原理、有序去重特性、迭代器遍历、API实战与面试核心考点全解
最新发布
2401_86195313的博客
06-15 374
我们深耕了数据结构核心——二叉搜索树（BST），彻底掌握了有序树形结构的增删查逻辑、有序特性与性能短板。我们明确知道，普通BST存在致命缺陷：有序数据插入会退化为链表，时间复杂度从O(logn)劣化为O(n)，完全无法用于工程开发。为了解决BST失衡问题，业界诞生了平衡二叉搜索树，而红黑树是综合性能最优、工业界最常用的平衡树，也是C++ STL有序容器的绝对底层支撑。今天我们学习的，并非简单的封装容器，其底层完全基于红黑树（Red-Black Tree）实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

庄家钜Java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值