看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

哈喽呀~~筒子们,小之最近在看 Spring 的源码,正好遇到几个 Aop 的问题涉及到Java的动态代理,之前对这个东西大致能理解,但是没有仔细的去看源码,今天我们来扒一扒它的真面目。

阅读本文,你将会收获:

  • 理解为什么 Jdk 动态代理,代理类必须实现接口

  • 理解 Jdk 动态代理全过程

  • 看到 Jdk 的动态代理类的类的内容

    如果只想看这个可以直接翻到最后/(ㄒoㄒ)/

  • 如何自己得到一个代理类的内容

  • 如何看源码

  • 变强

老规矩,上代码观现象

看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

依赖的类,明白上面的过程可以跳过不看

public interface HelloService {
    void sayHello();
}
/******************************************************/
public class HelloServiceImpl implements HelloService {
  @Override
  public void sayHello() {
    System.out.println("给掘金大佬们低头 (:");
  }
}
/****************************************************/
public class HelloInvocationHandle implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy before=======");
        Object result = method.invoke(target, args);
        System.out.println("proxy end=======");
        return result;
    }
}
复制代码

上面的代码,相信大家在学动态代理的时候,都有写过,我就不赘述了,大家有想过他是怎么实现的吗?为什么调代理类的sayHello()就可以直接使用 InvocationHandler 里的 invoke() 逻辑呢?为什么代理类必须要实现一个接口这么麻烦呢?我们继续往下面看。

源码分析

我们看上面的 Main 方法,可以看出来 Proxy.newProxyInstance() 这个方法承载了代理类的所有的逻辑,所有的魔法都在这里面

//生成一个代理对象
HelloService proxy = (HelloService) Proxy.newProxyInstance(
    Thread.currentThread().getContextClassLoader(),
    hello.getClass().getInterfaces(),handle);

复制代码

我们点进去,看看里面长啥样

private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) {
        ...
        //这里的interface数组里面放的是 HelloService,就是代理类需要实现的那个接口
        //这边复制了一份等待处理
        final Class<?>[] intfs = interfaces.clone();
        ...
        //得到了代理类的Class
        Class<?> cl = getProxyClass0(loader, intfs);
        ...
        //传入构造对象拿到代理类的构造器
        //从这里我们可以猜出这个代理类一个有一个构造方法是传入InvocationHandler进行初始化的
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        //通过反射传入之前我们定义的那个HelloInvocationHandle,进行构造器实例化代理对象
        return cons.newInstance(new Object[]{h});
复制代码

简单的分析一下上面的代码,流程也很简单

  • 传入 HelloService.class 类进行代理类的生成,这样代理类就有了原始类的方法信息,例如 sayHello()
  • 通过一个 InvocationHandler 这个构造对象拿到该代理类的构造方法
  • 传入之前我们定义的 HelloInvocationHandle ,构造器实例化了活生生的代理对象 从这里我们大致就能明白了 Jdk 动态代理的原理: 克隆一个接口,生成一个新类作为代理类,这个类里面有着我们定义的HelloInvocationHandle进行代理逻辑的处理

这里就回答了我们上面提到的一个问题: Jdk动态代理,代理类必须实现接口,是因为跟他的实现有关系,他规定了必须要传一个接口去生成代理类

所以所有的谜团就在生成代理类的 getProxyClass0(loader, intfs) 这个方法里

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
       ...
        // 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
        //这里从一个代理缓存的Cache中得到代理,Cache里面涉及虚引用实引用的东西不在我们讨论的范围里,我们直接看这个类是怎么生成的
        return proxyClassCache.get(loader, interfaces);
    }

//从上面的注释和这里我们都可以看出代理类是从一个叫ProxyClassFactory里生成的
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
     proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()); 
复制代码

看上面的注释我们可以看出到 ProxyClassFactory 负责生成代理类

我这里看的是 jdk1.8 的源码,用 lambda 重构过,旧版本看到的可以不一样,主逻辑应该没什么变化

// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    ...
    //这里定义了代理类的名字,所以你每次看到的代理类都是$Proxy开头的
    String proxyName = proxyPkg + proxyClassNamePrefix + num;
    //关键点在这里,这里生成一个代理类
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
    proxyName, interfaces, accessFlags);
}
复制代码

ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags) 这个方法如果感兴趣的大佬点进去可以看到,里面是用 StringBuilder 拼出了这个代理类的字节码(:,然后转成了 Byte 数组。

Bingo

关键点来了!这个代理类长啥样怎么看?Debug没有暴露出来啊亲,看不了,小之看到上面的 byte[] proxyClassFile 这个变量,漏出了一阵淫笑,前面说过,这个变量里存的是代理类字节码内容啊!没错! 输出流伺候! 小之一顿操作,QWER!飞起

看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

哦呵

看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

反编译,哦呵

public final class $Proxy0 extends Proxy implements HelloService {
    private static Method m1; //equals()方法
    private static Method m3; //sayHello()方法
    private static Method m2; //Bingo 我们的sayHello方法
    private static Method m0; //hashCode()方法
    
    //这里就是我们之前提交的InvocationHandler这个构造方法!!
    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})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    //勇士来吧!看一看我们的代理类的sayHello()方法长什么样子呀!!
    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("proxy.service.HelloService").getMethod("sayHello", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}
复制代码

筒子们,请聚焦上面的代理类 sayHello() 方法。真相大白了吧?代理类里实现了接口里的方法,全部调用了你的 HelloInvocationinvoke() 方法啦!

这里说一下上面的 super.h.invoke(this, m3, (Object[])null);super.h 是什么东西,明眼的大佬都应该看出来了吧?继承了Proxy类,是 Proxy 里定义的 InvocationHandler 变量,也就是你的 HelloInvocation

看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

总结

大佬们,是不是觉得 Jdk 动态代理也不是很复杂?好像自己也能写出来?哈哈,本篇文章还想提供一个 Debug 代码的思路,其实看源码没那么难,希望可以帮到大家,我们下次再见啦~

对了我这里安利一下我的 Github : 点我点我 目前正在做的几个东西:

Triple 自己写的一个 RPC 框架,练手的,功能不是很完善,主要目的是为了借助这个去理解网络相关的知识点,如 Netty ,想起来写一点~

数据结构和算法 数据结构和算法是薄弱项,多学学练练好吹吹:ox::beer:呀

Spring源码分析 还在分析,里面会整理一些问题,带着问题去看源码效率更高一点,欢迎大家有什么关于 Spring 的不懂的,可以给我提 Issue ,文章写好了应该也会发到掘金,毕竟基佬多(逃。

原文 

https://juejin.im/post/5caa2682e51d452b56319e37

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 看过Jdk动态代理类长啥样吗?Jdk动态代理原理源码一本到

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址