深入Proxy底层源码——实现自己的JDK动态代理

最新推荐文章于 2022-01-28 15:39:44 发布
最新推荐文章于 2022-01-28 15:39:44 发布
阅读量409 收藏 1
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/u/3995125/blog/3052261
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

写在前面：设计模式源于生活，而又高于生活！

JDK动态代理原理分析

  1. 在使用jdk动态代理的时候，必须要实现InvocationHandler接口；invoke方法中该三个参数分别表示为: 代理对象、被代理执行的方法、参数
public class JdkInvocationHandler implements InvocationHandler {
    /**
     * 被代理类对象 目标代理对象
     */
    private Object target;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(">>>jdk打印订单日志开始：proxy："+proxy.getClass().toString());
        Object reuslt = method.invoke(target, args);// java的反射机制执行方法 执行目标对象的方法
        System.out.println(">>>jdk打印订单日志结束");
        return reuslt;
    }

    /**
     * 使用jdk动态代理创建代理类
     *
     * @param <T>
     * @return
     */
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

2.使用jdk动态代理获取代理类对象（JDK自动生成代理类） $Proxy0.class，使用反编译工具

c8a15202ea5d2554013466dd6482b8252ff.jpg

纯手写动态代理原理分析

  1. 创建代理类$Proxy0源代码文件实现被代理的接口
public final class $Proxy0 extends java.lang.reflect.Proxy implements com.xuyu.service.OrderService {

    2.使用JavaCompiler技术编译该$Proxy0文件获取到$Proxy0.class

    3. 使用ClassLoader将该$Proxy0.class加入到当前JVM内存中

ClassLoader 顾名思义就是类加载器,ClassLoader 作用：负责将 Class 加载到 JVM 中,审查每个类由谁加载（父优先的等级加载机制）,将 Class字节码 重新解析成 JVM 统一要求的对象格式

纯手写v1.0版本jdk动态代理

1.自定义MyExtJdkInvocationHandler接口 ——相当于InvocationHandler

/**
 * @title: MyExtJdkInvocationHandler 
 */
public interface MyExtJdkInvocationHandler {
    /**
     * @param proxy  代理类
     * @param method 目标方法
     * @param args   参数
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

2.写一个MyJdkInvocationHandler实现MyJdkInvocationHandler接口

/**
 * @title: MyJdkInvocationHandler
 */
public class MyJdkInvocationHandler implements MyExtJdkInvocationHandler {
    /**
     * 目标对象 被代理的类 真实访问的类的对象
     */
    private Object target;

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

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("<<<<<<<<<纯手写jdk动态代理日志开始>>>>>>>>>>");
        Object result = method.invoke(target, args);// 使用java的反射执行
        System.out.println("<<<<<<<<纯手写jdk动态代理结束>>>>>>>>>>");
        return result;
    }
}

service层

public interface OrderService {

    public void order() throws Throwable;
}
/**
 * @title: OrderServiceImpl
 */
public class OrderServiceImpl implements OrderService {

    public void order() {
        System.out.println("数据库订单执行操作");
    }
}

3.对比反编译$Proxy0.class来写$Proxy0

e051b1745de38261f243ae7059b476772f6.jpg

4.简单测试

public class Test001 {
    public static void main(String[] args) throws Throwable {
        OrderService  orderService = new $Proxy0(new MyJdkInvocationHandler(new OrderServiceImpl()));
        orderService.order();
    }
}

5.控制台输出结果

<<<<<<<<<纯手写jdk动态代理日志开始>>>>>>>>>>
数据库订单执行操作
<<<<<<<<纯手写jdk动态代理结束>>>>>>>>>>

纯手写v2.0版本jdk动态代理

1.先看源码Proxy怎么实现的

public class Proxy implements java.io.Serializable {
    ....
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    ....
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        //【2】获取代理类，写入到到本地文件中..
        return proxyClassCache.get(loader, interfaces);
    }
    ....
    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        private static final String proxyClassNamePrefix = "$Proxy";
        private static final AtomicLong nextUniqueNumber = new AtomicLong();
        //【3】将源代码编译成class文件，帮助我们初始化，创建class文件
        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                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;  
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
            for (Class<?> intf : interfaces) {
               。。。。
            }
            if (proxyPkg == null) {
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            //####原子类，自增，保证线程安全，原子类计数代理类proxy0,proxy1,proxy2....####
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //####创建Java源代码，转化为字节码文件####
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                //【4】使用classLoader 加载到内存中，代理类class文件加载到内存####
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }
    ....
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        。。。。
        //【1】创建代理类java源码文件,写入到硬盘中..
        Class<?> cl = getProxyClass0(loader, intfs);
       
        。。。。

1.总结相关要点

1.创建代理类java源码文件,写入到硬盘中..
2. 写入到到本地文件中..
3. 将源代码编译成class文件
4.使用classLoader 加载到内存中..

2.模仿源码写代码

/**
 * @title: MyProxy
 */
public class MyProxy {
    static String rt = "\r\t";

    public static Object newProxyInstance(JavaClassLoader javaClassLoader,
                                          Class<?> classInfo,
                                          MyExtJdkInvocationHandler h) {
        //1.拼接代理类的源代码
        try {

            // 1.创建代理类java源码文件,写入到硬盘中..
            Method[] methods = classInfo.getMethods();
            String proxyClass = "package com.xuyu.ext.proxy;" + rt
                    + "import java.lang.reflect.Method;" + rt
                    + "import com.xuyu.ext.proxy.MyExtJdkInvocationHandler;" + rt
                    + "public class $Proxy0 implements " + classInfo.getName() + "{" + rt
                    + "MyExtJdkInvocationHandler h;" + rt
                    + "public $Proxy0(MyExtJdkInvocationHandler h)" + "{" + rt
                    + "this.h= h;" + rt + "}"
                    + getMethodString(methods, classInfo) + rt + "}";
            // 2. 写入到到本地文件中..
            String filename = "d:/code/$Proxy0.java";
            File f = new File(filename);
            FileWriter fw = new FileWriter(f);
            fw.write(proxyClass);
            fw.flush();
            fw.close();
            // 3. 将源代码编译成class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
            Iterable units = fileMgr.getJavaFileObjects(filename);
            JavaCompiler.CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
            t.call();
            fileMgr.close();
            // 4.使用classLoader 加载到内存中..
            Class<?> $Proxy0 = javaClassLoader.findClass("$Proxy0");
            // 5.指明初始化有参数构造函数
            Constructor<?> constructor = $Proxy0.getConstructor(MyExtJdkInvocationHandler.class);
            Object o = constructor.newInstance(h);
            return o;

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    public static String getMethodString(Method[] methods, Class intf) {
        String proxyMe = "";
        for (Method method : methods) {
            proxyMe += "public void " + method.getName() + "() throws Throwable {" + rt
                    + "Method md= " + intf.getName() + ".class.getMethod(\"" + method.getName()
                    + "\",new Class[]{});" + rt
                    + "this.h.invoke(this,md,null);" + rt + "}" + rt;

        }
        return proxyMe;
    }

    public static void main(String[] args) {
        newProxyInstance(null, OrderService.class, null);
    }

}

3.看源码怎么实现ClassLoader类加载器

61a1dd623cf01bc51cbe4f3637d4232a95e.jpg

4.写出自己的JavaClassLoader 类加载器

public class JavaClassLoader extends ClassLoader {

    private File classPathFile;

    public JavaClassLoader(){
        String classPath="D:\\code";
        this.classPathFile=new File(classPath);
    }

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        String className= JavaClassLoader.class.getPackage().getName()+"."+name;
        if(classPathFile!=null){
          File classFile=new File(classPathFile,name.replaceAll("\\.","/")+".class");
          if(classFile.exists()){
              FileInputStream in=null;
              ByteArrayOutputStream out=null;
              try {
                  in=new FileInputStream(classFile);
                  out=new ByteArrayOutputStream();
                  byte[] buff=new byte[1024];
                  int len;
                  while ((len=in.read(buff))!=-1){
                     out.write(buff,0,len);
                  }
                  return defineClass(className,out.toByteArray(),0,out.size());
              }catch (Exception e){
                  e.printStackTrace();
              }finally {
                  if(in!=null){
                      try {
                          in.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  if(out!=null){
                      try {
                          out.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
          }
        }
        return null;
    }

5.测试类

/**
 * @title: Test001
 */
public class Test001 {
    public static void main(String[] args) throws Throwable {

        OrderService orderService = (OrderService) MyProxy.newProxyInstance(new JavaClassLoader(),
                OrderService.class, new MyJdkInvocationHandler(new OrderServiceImpl()));
        orderService.order();
    }
}

aa5c58fa10fcd40061c3289214b37b882b4.jpg

6.运行程序生成的$Proxy0.java文件内容

package com.xuyu;

import com.xuyu.ext.proxy.MyExtJdkInvocationHandler;

import java.lang.reflect.Method;


public class $Proxy0 implements com.xuyu.service.OrderService {
    MyExtJdkInvocationHandler h;

    public $Proxy0(MyExtJdkInvocationHandler h) {
        this.h = h;
    }

    public void order() throws Throwable {
        Method md = com.xuyu.service.OrderService.class.getMethod("order",
                new Class[] {  });
        this.h.invoke(this, md, null);
    }
}

7.控制台输出结果

<<<<<<<<<纯手写jdk动态代理日志开始>>>>>>>>>>
数据库订单执行操作
<<<<<<<<纯手写jdk动态代理结束>>>>>>>>>>

版权@须臾之余https://my.oschina.net/u/3995125

 

转载于:https://my.oschina.net/u/3995125/blog/3052261

weixin_33814685
关注
Spring——AOP的jdk与cglib动态代理
casey_xiaoxin的博客
09-24 249
AOP简述 一个初学者的学习笔记 面向切面编程 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 下面展示AOP的两种动态代理 文章目录AOP简述一.JDK 动态代理二.Cglib动态代理 一.JDK 动态代理 JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的，只能对
Spring源码——AOP
等一杯咖啡的博客
10-21 2263
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
Proxy源代码
03-19
Proxy源代码分析 ，linux网络编程入门相当好的资料，已经通过编译。 具体分析请见： http://blog.csdn.net/gfsfg8545/article/details/8687139
Jdk动态代理 底层源码
bugpool的博客
03-16 8728
前言 java动态代理主要有2种，Jdk动态代理、Cglib动态代理，本文主要讲解Jdk动态代理的使用、运行机制、以及源码分析。当spring没有手动开启Cglib动态代理，即：<aop:aspectj-autoproxy proxy-target-class="true"/>或@EnableAspectJAutoProxy(proxyTargetClass = true)，默认使用的...
JDK代理：Proxy源码详解
李思苇
11-15 1556
Proxy类中定义了一个缓存，用于存储当前应用生成的所有代理类。缓存的数据实际存储在一个ConcurrentHashMap中，我们称之为cache-map。cache-map对所有代理类的存储，是以每个代理类的类加载器为分组依据，将同一个类加载器加载的所有代理类分为一组。如此，将有相同类加载器的一组代理类的类加载器对象作为key，将这组代理类构成的一个集合作为value，存储在cache-map中。 cache-map的key的类型是ClassLoader，存储代理类的类加载器。 cache-map的val
Proxy源代码分析--谈谈如何学习linux网络编程
weixin_34366546的博客
01-08 107
Linux是一个可靠性非常高的操作系统，但是所有用过Linux的朋友都会感觉到，Linux和Windows这样的"傻瓜"操作系统（这里丝毫没有贬低Windows的意思，相反这应该是Windows的优点）相比，后者无疑在易操作性上更胜一筹。但是为什么又有那么多的爱好者钟情于Linux呢，当然自由是最吸引人的一点，另外Linux强大的功能也是一个非常重要的原因，尤其是Linux强大的网络功能更是引人注...
java核心技术——代理（Proxy）附源码
qq_45251343的博客
08-14 872
一、了解代理 代理(Proxy) 是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法 java中的代理模式： 定义：给目标对象提供一个代理对象，并且由代理对象控制对目标对象的引用 目的： ①：通过代理对象的方式间接的访问目标对象，防止直接访问目标对象给系统带来不必要的复杂性 ②：
精尽 Dubbo 源码分析 —— 动态代理（一）之 Javassist
qq_32782279的博客
04-05 462
1.概述 在 《Dubbo 用户指南 —— schema 配置参考手册》 中，我们可以看到 <dubbo:service /> 和 <dubbo:reference /> 标签中，可以通过 “proxy” 属性，可以配置动态代理的生成方式： 生成动态代理方式，可选：jdk / javassist 2.整体流程 在 Consumer 中，我们调用 Service 接口的方法...
Spring 源码解析——@Configuration 作用及其实现原理（一）
Coder Yang
09-21 3703
目录 一、概述 二、相关技术 2.1 @Configuration 作用 2.2 BeanDefinition 和BeanDefinitionMap 2.3 CGLIB 简介 三、源码解析 3.1 概述 3.2register（Bean 注册流程） 3.3 refresh（BeanClass 的替换） 四、内容总结 写文章不易，转载请标明出处。 同时，如果你喜欢我的文...
JavaSE——单元测试、反射、注解、动态代理
qq_46002941的博客
01-28 966
文章目录单元测试单元测试概述单元测试快速入门单元测试常用注解反射反射概述反射获取类对象反射获取构造器对象反射获取成员变量对象反射获取方法对象反射的作用-绕过编译阶段为集合添加数据反射的作用-通用框架的底层原理注解注解概述自定义注解元注解注解解析案例：注解解析的案例注解的应用场景一：Junit框架动态代理 单元测试 单元测试概述 单元测试 单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。 目前测试方法是怎么进行
Proxy源代码分析(包括源码分析和可在Linux下运行的源码)
01-02
首先声明，这段源代码不是我编写的，让我们感谢这位名叫Carl Harris的大虾，是他编写了这段代码并将其散播到网上供大家学习讨论。这段代码虽然只是描述了最简单的proxy操作，但它的确是经典，它不仅清晰地描述了客户机/服务器系统的概念，而且几乎包括了Linux网络编程的方方面面，非常适合Linux网络编程的初学者学习。 　　这段Proxy程序的用法是这样的，我们可以使用这个proxy登录其它主机的服务端口。假如编译后生成了名为Proxy的可执行文件，那么命令及其参数的描述为： 　　　./Proxy 　　其中参数proxy_port是指由我们指定的代理服务器端口。参数remote_host是指我们希望连接的远程主机的主机名，IP地址也同样有效。这个主机名在网络上应该是唯一的，如果您不确定的话，可以在远程主机上使用uname -n命令查看一下。参数service_port是远程主机可提供的服务名，也可直接键入服务对应的端口号。这个命令的相应操作是将代理服务器的proxy_port端口绑定到remote_host的service_port端口。然后我们就可以通过代理服务器的proxy_port端口访问remote_host了。例如一台计算机，网络主机名是legends，IP地址为10.10.8.221，如果在我的计算机上执行： 　　　[root@lee /root]#./proxy 8000 legends telnet 　　那么我们就可以通过下面这条命令访问legends的telnet端口。 ----------------------------------------------------------------- [root@lee /root]#telnet legends 8000 Trying 10.10.8.221... Connected to legends(10.10.8.221). Escape character is '^]' Red Hat Linux release 6.2(Zoot) Kernel 2.2.14-5.0 on an i686 Login: -----------------------------------------------------------------
jdk与cglib动态代理与底层实现
12-21
代理模式详解-jdk与cglib动态代理与底层实现，spring中常用的设计模式，本案例是从源码到代理模式的实现。
Proxy源码解析。
孤芳不自赏
08-27 1314
/** * Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。 * * 创建某一接口 Foo 的代理： * * InvocationHandler handler = new MyInvocationHandler(...); * Class proxyClass = Proxy.getProxyClass( * ...
Proxy Server源码及分析
牛仔的blog
12-14 6563
本文主要讲代理服务器源码，是一位叫Carl Harris大神写的，非常简单易懂，把代理服务器（Proxy Server）本质完全体现出来。相信读懂了这段代码，以后想搞定http代理等其他类型的代理服务器也能行。在附录中会贴出proxy全部源码，仅供学习使用。一、代理服务器的定义代理服务器（Proxy Server）是一种重要的服务器安全功能，它的工作主要在开放系统互联(OSI)模型的会话层，从而起到
Proxy源码分析
GetStudyMessages的专栏
03-27 3133
<br /><br />1.验证InvocationHandler是否空<br />2.生成代理类的Class对象，这里戏份比较多，代码中详细注释。<br />(1).通过类加载器去加载得到Class实例，比较是否想通的Class<br />(2).判断是否是接口<br />(3).去重Class，并通过String[]保存接口名<br />(4).从缓存中创建根据类加载器取得Map，如果没有则创建一个，保存到WeakHashMap<br />(5). put key,value<一堆接口，正在创建代理的标
proxy.c
Jerry's Tech Notes Home
05-25 873
 /****************************************************************************  program:      proxyd  module:       proxyd.c  summary:      provides proxy tcp service for a host on an isolated network
JDK中Proxy类源码
杨春建的博客
12-23 772
JDK中Proxy类源码 public class Proxy implements java.io.Serializable { private static final long serialVersionUID = -2222568056686623797L; /** parameter types of a proxy class constructor */
JDK动态代理底层源码剖析
逍遥云中鸟
09-01 355
1. 动态代理相关概念 目标类：程序员自己写的、普通的业务类，是需要被代理的类； 目标方法：目标类中的实现业务的具体方法，为了精简，只写核心业务代码，因此需要代理类来增强功能； 增强器：是给目标方法增强功能的类，需要继承InvocationHandler接口，实现invoke(Object proxy, Method method, Object[] args)方法； 代理类：由JDK相关类在程序执行过程中、为了给目标类的相关目标方法增强功能而生成的、存在于内存中的类； 动态代理：在程序执行过程中，由JD
深入解析Jdk动态代理：原理与源码分析
我们将通过一个模拟@Cacheable注解的例子来展示动态代理如何处理缓存，并深入源码来解答为何Jdk动态代理需要目标对象实现接口。" ### Jdk动态代理简介 Java的动态代理机制允许在运行时创建一个实现了特定接口的新类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值