JDK动态代理深入解析

最新推荐文章于 2024-03-24 21:20:42 发布
最新推荐文章于 2024-03-24 21:20:42 发布
阅读量162 收藏
点赞数
文章标签： jdk 代理模式 jdk动态代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AS_JOPO/article/details/117962688
版权

一、首先动态代理区别与静态代理（关于代理模式，这里不做说明，有大量的博文在讲这个概念），是程序在运行过程中创建目标接口的代理实现类。

二、下面先看一段简单的代码：

Map map = (Map) Proxy.newProxyInstance(TestProxy.class.getClassLoader(), new Class[]{Map.class}, (proxy, method, args1) -> {
    if (method.getName() == "get") {
        return "world";
    } else {
        System.out.println("不支持该方法调用");
        return null;
    }
});

System.out.println("hello  " + map.get("hello"));
map.put("a", "b");

这一段代码就创建了一个Map接口的动态代理类的实例，并调用了map的get和put方法。控制台输出如下：

这里发现一个奇怪的现象，我们并没有map接口的实现类，却得到了map对象，并调用了map接口的两个方法。

Java最基本的规则告诉我们，对象一定是一个实现类的实例，不可能直接创建一个接口的实例（即使是使用匿名内部类，也符合这条规则）。由这一点出发，我们可以判断Proxy类的newProxyInstance方法内部一定创建了一个Map接口的实现类，并被ClassLoader加载到了JVM，最后还创建了这个实现类的实例。下面对jdk源码的跟踪证实了这一设想：

1.创建Map接口的实现类。

追踪到Proxy.java 的第535行，可以发现jdk动态生成了Map接口的实现类，并加载到了JVM。

 进一步从Proxy.java的538行追踪到ProxyGenerator类的第527行，会看到class类文件头的魔法数 CAFFBABE（这个魔法数还有个浪漫的故事），说明JDK确实在创建一个Map接口的实现类。

 

在调试Proxy.java第538行的时候执行如下代码，可以将JDK生成的类输出到proxy.class文件：

new FileOutputStream("/Users/XXX/Downloads/tt/proxy.class").write(proxyClassFile)

生成的calss文件反编译后结果如下：


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 java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

public final class $Proxy0 extends Proxy implements Map {
    private static Method m1;
    private static Method m21;
    private static Method m5;
    private static Method m3;
    private static Method m4;
    private static Method m22;
    private static Method m0;
    private static Method m7;
    private static Method m16;
    private static Method m24;
    private static Method m8;
    private static Method m17;
    private static Method m9;
    private static Method m20;
    private static Method m2;
    private static Method m14;
    private static Method m23;
    private static Method m19;
    private static Method m25;
    private static Method m6;
    private static Method m10;
    private static Method m11;
    private static Method m12;
    private static Method m18;
    private static Method m15;
    private static Method m13;

    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 Object computeIfAbsent(Object var1, Function var2) throws  {
        try {
            return (Object)super.h.invoke(this, m21, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

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

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

    public final boolean containsValue(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m22, 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);
        }
    }

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

    public final void putAll(Map var1) throws  {
        try {
            super.h.invoke(this, m16, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Object getOrDefault(Object var1, Object var2) throws  {
        try {
            return (Object)super.h.invoke(this, m24, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

    public final Object putIfAbsent(Object var1, Object var2) throws  {
        try {
            return (Object)super.h.invoke(this, m17, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

    public final boolean containsKey(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m20, 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 Object merge(Object var1, Object var2, BiFunction var3) throws  {
        try {
            return (Object)super.h.invoke(this, m14, new Object[]{var1, var2, var3});
        } catch (RuntimeException | Error var5) {
            throw var5;
        } catch (Throwable var6) {
            throw new UndeclaredThrowableException(var6);
        }
    }

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

    public final void forEach(BiConsumer var1) throws  {
        try {
            super.h.invoke(this, m19, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Object computeIfPresent(Object var1, BiFunction var2) throws  {
        try {
            return (Object)super.h.invoke(this, m25, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final Object put(Object var1, Object var2) throws  {
        try {
            return (Object)super.h.invoke(this, m6, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final Object replace(Object var1, Object var2) throws  {
        try {
            return (Object)super.h.invoke(this, m10, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

    public final void replaceAll(BiFunction var1) throws  {
        try {
            super.h.invoke(this, m12, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final Object compute(Object var1, BiFunction var2) throws  {
        try {
            return (Object)super.h.invoke(this, m18, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

    public final int size() throws  {
        try {
            return (Integer)super.h.invoke(this, m13, (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"));
            m21 = Class.forName("java.util.Map").getMethod("computeIfAbsent", Class.forName("java.lang.Object"), Class.forName("java.util.function.Function"));
            m5 = Class.forName("java.util.Map").getMethod("get", Class.forName("java.lang.Object"));
            m3 = Class.forName("java.util.Map").getMethod("remove", Class.forName("java.lang.Object"));
            m4 = Class.forName("java.util.Map").getMethod("remove", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m22 = Class.forName("java.util.Map").getMethod("containsValue", Class.forName("java.lang.Object"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m7 = Class.forName("java.util.Map").getMethod("values");
            m16 = Class.forName("java.util.Map").getMethod("putAll", Class.forName("java.util.Map"));
            m24 = Class.forName("java.util.Map").getMethod("getOrDefault", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m8 = Class.forName("java.util.Map").getMethod("clear");
            m17 = Class.forName("java.util.Map").getMethod("putIfAbsent", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m9 = Class.forName("java.util.Map").getMethod("isEmpty");
            m20 = Class.forName("java.util.Map").getMethod("containsKey", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m14 = Class.forName("java.util.Map").getMethod("merge", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"), Class.forName("java.util.function.BiFunction"));
            m23 = Class.forName("java.util.Map").getMethod("keySet");
            m19 = Class.forName("java.util.Map").getMethod("forEach", Class.forName("java.util.function.BiConsumer"));
            m25 = Class.forName("java.util.Map").getMethod("computeIfPresent", Class.forName("java.lang.Object"), Class.forName("java.util.function.BiFunction"));
            m6 = Class.forName("java.util.Map").getMethod("put", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m10 = Class.forName("java.util.Map").getMethod("replace", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m11 = Class.forName("java.util.Map").getMethod("replace", Class.forName("java.lang.Object"), Class.forName("java.lang.Object"), Class.forName("java.lang.Object"));
            m12 = Class.forName("java.util.Map").getMethod("replaceAll", Class.forName("java.util.function.BiFunction"));
            m18 = Class.forName("java.util.Map").getMethod("compute", Class.forName("java.lang.Object"), Class.forName("java.util.function.BiFunction"));
            m15 = Class.forName("java.util.Map").getMethod("entrySet");
            m13 = Class.forName("java.util.Map").getMethod("size");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

以上代码就是典型的代理模式了。2.创建动态代理类的实例

Proxy.java的第1022行，使用动态代理类的构造器创建实例

 

as_jopo
关注
2.3.2 JDK动态代理 -《SSM深入解析与项目实战》
谙忆-陈浩翔
08-14 1216
文章目录2.3.2 JDK动态代理实现类和接口演示演示结果代理类优化 2.3.2 JDK动态代理 JDK动态代理是由Java内部使用反射机制来实现的。使用JDK动态代理必须是委托类实现统一的接口，否则JDK动态代理不能应用。虽然有一定的局限性，但是影响不大。java.lang.reflect包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。所以如果需要代理，我们代理类必须InvocationHandler 接口或者继承Proxy类。建议使用InvocationHan
万字文章|JDK动态代理及其源码解析 拿捏了
小牛呼噜噜的博客
11-15 385
静态代理：在编译时就已经实现，编译完成后代理类是一个实际的class文件代理类和委托类的关系在程序运行前就已确定动态代理：在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中代理类和委托类的关系是在程序运行时确定。
jdk动态代理技术详解
06-30
jdk动态代理技术详解，可以学习一下，不错的
Java动态代理深入解析
weixin_30706691的博客
01-25 93
要想了解Java动态代理，首先要了解什么叫做代理，熟悉设计模式的朋友一定知道在Gof总结的23种设计模式中，有一种叫做代理(Proxy)的对象结构型模式，动态代理中的代理，指的就是这种设计模式。 在我看来所谓的代理模式，和23种设计模式中的“装饰模式”是一个东西。23种设计模式中将它们作为两种模式，网上也有些文章讲这两种模式的异同，从细节来看，确实可以人为地区分这两种模式，但是抽象到一定高度后，...
JDK动态代理详解
weixin_34362790的博客
12-23 119
2019独角兽企业重金招聘Python工程师标准>>> ...
深入分析JDK动态代理
weixin_30444105的博客
03-05 65
一、动态代理的使用 public class Test { //被代理的接口 public interface IHello { void sayHello(); } //接口的实现类 static class Hello implements IHello { public void sayHe...
JDK的动态代理深入解析
i_am_beautiful_Girl的博客
07-07 207
JDK的动态代理深入解析（Proxy,InvocationHandler）（转） 一、什么是动态代理 　　动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。 &nbsp...
JDK动态代理原理解析
qq_31543867的博客
09-29 3086
JDK动态代理原理解析 本文章不介绍什么是动态代理，而是讲解原理 Demo代码 我有一个Animal接口 public interface Animal { void eat(); } 有一个Dog类实现了Animal接口 public class Dog implements Animal { @Override public void eat() { System.out.println("animal eat..."); } } 现在我想调用eat方
关于jdk动态代理的源码剖析
06-18
本文将深入分析JDK动态代理的工作原理及其内部实现机制。 #### 二、为什么需要JDK动态代理？ 在实际开发中，经常会遇到需要为已有的类添加新功能的需求，但又不能直接修改这些类的源码。此时，动态代理技术就显得...
JDK动态代理源码
11-30
下面将深入解析JDK动态代理的核心知识点及其在实际中的应用。 1. **Java.lang.reflect.Proxy**：这是JDK动态代理的关键类，它提供了创建动态代理对象的工厂方法`newProxyInstance()`。这个方法接收三个参数：`...
代理模式，JDK动态代理，SpringAOP来龙去脉
05-27
在Java中，我们可以使用JDK的动态代理或者Spring AOP来实现代理模式。 JDK动态代理主要依赖于`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。Proxy类是生成代理对象的工厂，而...
JDK动态代理的深入理解
舞鹤白沙编码日志
12-25 264
引入代理模式 代理模式是框架中经常使用的一种模式，动态代理是AOP（面向切面编程）思想的一种重要的实现方式，在我们常用的框架中也经常遇见代理模式的身影，例如在Spring中事务管理就运用了动态代理，它将Service层原先应该进行的事务管理交给了Spring框架，大大简化了开发流程。在Hibernate中对象的懒加载模式，也运用了JDK的动态代理以及cglib代理。 静态代理 在说动态代理之前，我们需要先了解...
深入探索JDK动态代理：从入门到原理的全面解析
最新发布
Apple_Boy的博客
03-24 2042
为了调试目的，我们要查看或修改这些动态生成的代理类，正常我们还需要反编译工具（比如JD-GUI或JAD）来查看生成的类的源代码，但是我们不用那么麻烦，直接用IDEA打开即可。在标准的Java JDK实现中，生成的动态代理类（字节码）默认是在内存中动态生成并直接加载的，不会写入磁盘成为文件。现在，我们可以编写一个测试类来验证动态代理的使用，这个例子中，我们通过动态代理实现了一个代理对象，当调用代理对象的方法时，会先执行。添加了这个系统属性后，当创建动态代理实例的时候，JVM会将生成的代理类以。
深入理解 jdk 动态代理的实现
wei_ya_wen的专栏
03-15 865
最近发现，java框架中大量使用了 动态代理。 原来只是会简单的使用，但是今天想深入研究下jdk是如何实现的。 一个比较靠谱的博客：http://www.cnblogs.com/flyoung2008/archive/2013/08/11/3251148.html 至于Proxy 怎么用，在这里就不赘述了。关键是想说说 jdk怎么实现的。 主要想讲讲 这个方法  Proxy.get
代理模式深入（二）——动态代理实现机制
忠麦一生
08-18 1766
上篇博客由于长度的原因，只是用代码展示了静态代理到动态代理的“进化”。那么本篇博客就动态代理的实现原理做一个介绍，从而有一个更深入的理解。当然，这也已经渐渐的脱离的代理模式的内容，因为学习是一个管中窥豹的过程，了解的越深入才能了解事务的本质。     问题重现     动态代理呢解决了静态代理的两个在一定条件下不适应的问题：其一，因为代理类中需要持有一个实际类而导致的代理类和实际类的耦合度
深入理解动态代理
losemyfuture的博客
12-03 198
1、代理特点 执行者、被代理人 对于被代理人来说，这件事情一定要做，但是又不想去做或者没时间去做 需要获取被代理人的个人资料 2、jdk动态代理 这里以一个买票的实例进行深入 买票服务 public interface Person { //买票 void butTicket(); String getBegin(); String getNam...
一篇文章讲清楚Java动态代理
YunWQ的博客
06-04 338
Java动态代理概述 首先我们解释一下代理是什么意思，大家的微信里有很多做微商的朋友。很多微商的销售模式就是代理模式。比如店主小二在微信朋友圈卖衣服，小王看到了小二发的朋友圈就找小二买衣服，而小二只是一个代理商，它的衣服是从小一那里拿的。 在这个过程中小二就是小一的代理，代理对卖衣服这个行为进行的增强，把原来10块钱一件的衣服卖到了20块，并且购买成功还赠送小礼品。 Java动态代理指的是在程序运行时，为已有对象生成代理对象，对原有对象的方法进行功能增强。 目标接口和实现类 JDK动态代理要求目标类（被代
JDK 动态代理详解
男人要霸气的博客
04-27 239
文章目录什么是动态代理如何使用动态代理动态代理使用场景实例 什么是动态代理 在不改变原始类代码的情况下，实现原始类功能的增强 动态代理是java中23设计模式里的一种，也称代理模式，也是开发中经常用到的设计模式。 如何使用动态代理 Proxy类是jdk提供的代理类，基于接口的，常用newProxyInstance方法如下： public static Object newProxyInstan...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值