如何手写JDK动态代理

最新推荐文章于 2023-07-10 11:00:42 发布
最新推荐文章于 2023-07-10 11:00:42 发布
阅读量169 收藏
点赞数
分类专栏： 设计模式 文章标签： Java 设计模式 动态代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanlei1990918/article/details/83149819
版权
1、关于静态代理和动态代理的区别

静态代理：

由程序员事先生成源代码再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理类：

在程序运行时，运用 Java 反射机制动态创建而成。

两者比较：

  1. 静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
  2. 静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。
  3. 动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。
  4. 还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。
2、JDK 动态代理的实现
  1. Person.java 接口类
package com.leitan.architect.pattern.proxy.sta;

/**
 * @Author: tan.lei
 * @Date: 2018-10-17 14:45
 */
public interface Person {

    void findPartner();

    void findHouse();

    void findJob();

    void shopping();

}
  1. Xiaoming.java 被代理类
package com.leitan.architect.pattern.proxy.jdk;

import com.leitan.architect.pattern.proxy.sta.Person;

/**
 * @Author: tan.lei
 * @Date: 2018-10-17 14:52
 */
public class Xiaoming implements Person {

    @Override
    public void findPartner() {
        System.out.println("需要肤白、貌美、大长腿的伴侣....");
    }

    @Override
    public void findHouse() {
        System.out.println("需要环境安静的房子");
    }

    @Override
    public void findJob() {
        System.out.println("需要高薪的工作");
    }

    @Override
    public void shopping() {
        System.out.println("需要160m²的海景别墅");
    }
}
  1. MyInvocationHandler.java 处理接口，类似参考 JDK 的 InvocationHandler
package com.leitan.architect.pattern.proxy.mine;

import java.lang.reflect.Method;

/**
 * @Author: tan.lei
 * @Date: 2018-10-17 16:49
 */
public interface MyInvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
  1. MyMeipo.java 媒婆的实现类
package com.leitan.architect.pattern.proxy.mine;

import com.leitan.architect.pattern.proxy.sta.Person;

import java.lang.reflect.Method;

/**
 * @Author: tan.lei
 * @Date: 2018-10-18 10:09
 */
public class MyMeipo implements MyInvocationHandler {


    private Person target;// 被代理的对象,把引用保存下来


    public Object getInstance(Person target) throws Exception {
        this.target = target;

        Class<?> clazz = target.getClass();

        // 用来生成一个新对象(字节码重组来实现)
        return MyProxy.newProxyInstance(new MyClassLoader(), clazz.getInterfaces(), this);

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("请给我你的需求,开始帮你物色...");

        method.invoke(this.target, args);// 目标类的方法调用，需要找媳妇的条件

        System.out.println("如果找到符合要求的就安排给你!");

        return null;
    }
}

根据媒婆的要求，目前还需要

MyProxy.java 需要动态生成的代理类

MyClassLoader.java 自定义的类加载器

  1. MyProxy.java 代理类
package com.leitan.architect.pattern.proxy.mine;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * @Author: tan.lei
 * @Date: 2018-10-17 16:48
 */
public class MyProxy {

    private static final String LN = "\r\n";// 换行


    /**
     * 获取动态代理类
     *
     * @param classLoader 自定义的类加载器
     * @param interfaces  被代理的目标接口
     * @param handler     实际的业务处理实现
     * @return
     */
    public static Object newProxyInstance(MyClassLoader classLoader, Class<?>[] interfaces, MyInvocationHandler handler) {

        try {
            // 1.动态生成源代码.java文件
            String src = generateSrc(interfaces);

            // 2.Java文件输出到磁盘
            String filePath = MyProxy.class.getResource("").getPath();
            System.out.println("FilePath = " + filePath);
            File f = new File(filePath + "$Proxy0.java");

            FileWriter fw = new FileWriter(f);
            fw.write(src);
            fw.flush();
            fw.close();

            // 3.把.java文件编译成.class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manager.getJavaFileObjects(f);
            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();

            // 4.把.class加载到JVM中
            Class proxyClass = classLoader.findClass("$Proxy0");
            Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
            f.delete();// 编译完成首删除.java原文件

            // 5.返回字节码重组后新生成的对象
            return constructor.newInstance(handler);

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

        return null;
    }

    /**
     * 拼接需要动态生成代理类的字符串内容
     *
     * @param interfaces 被代理类的接口
     * @return
     */
    private static String generateSrc(Class<?>[] interfaces) {
        StringBuffer sb = new StringBuffer();
        sb.append("package com.leitan.architect.pattern.proxy.mine;" + LN);
        sb.append(LN);

        sb.append("import " + interfaces[0].getName() + ";" + LN);
        sb.append("import java.lang.reflect.Method;" + LN);
        sb.append(LN);

        sb.append("public class $Proxy0 implements " + interfaces[0].getSimpleName() + " {" + LN);
        sb.append(LN);

        sb.append("public MyInvocationHandler handler;" + LN);
        sb.append(LN);

        sb.append("public $Proxy0(MyInvocationHandler handler) {" + LN);
        sb.append("this.handler = handler;" + LN);
        sb.append("}" + LN);
        sb.append(LN);

        for (Method method : interfaces[0].getMethods()) {
            sb.append("public " + method.getReturnType().getName() + " " + method.getName() + "() {" + LN);
            sb.append("try {" + LN);
            sb.append("Method m = " + interfaces[0].getSimpleName() + ".class.getMethod(\"" + method.getName() + "\", new Class[]{});" + LN);
            sb.append("this.handler.invoke(this, m, null);" + LN);
            sb.append("} catch(Throwable e) { " + LN);
            sb.append("e.printStackTrace();" + LN);
            sb.append("}" + LN);
            sb.append("}" + LN);
            sb.append(LN);
        }

        sb.append("}" + LN);

        return sb.toString();
    }

}
  1. MyClassLoader.java 自定义类加载器
package com.leitan.architect.pattern.proxy.mine;

import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @Author: tan.lei
 * @Date: 2018-10-17 16:50
 */
public class MyClassLoader extends ClassLoader {

    private File classPathFile;// class的存放路径

    public MyClassLoader() {
        String classPath = MyClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> resClass = null;

        if (classPathFile != null) {
            File classFile = new File(classPathFile, name.replaceAll("\\.", "/") + ".class");
            if (classFile.exists()) {
                FileInputStream in = null;
                ByteOutputStream out = null;// 把class转换成字节码写到JVM中
                try {
                    in = new FileInputStream(classFile);
                    out = new ByteOutputStream();
                    byte[] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1) out.write(buff, 0, len);

                    String className = MyClassLoader.class.getPackage().getName() + "." + name;
                    resClass = defineClass(className, out.getBytes(), 0, out.size());
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if (in != null) in.close();
                        if (out != null) out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return resClass;
    }
}
  1. MyProxyTest.java 测试类
package com.leitan.architect.pattern.proxy.mine;

import com.leitan.architect.pattern.proxy.jdk.Xiaoming;
import com.leitan.architect.pattern.proxy.sta.Person;

/**
 * @Author: tan.lei
 * @Date: 2018-10-18 10:07
 */
public class MyProxyTest {


    public static void main(String[] args) {
        try {
            Person obj = (Person) new MyMeipo().getInstance(new Xiaoming());
            System.out.println(obj.getClass());// 这个类是字节码动态生成的
            // 你在这里看似调用目标类的方法，实际上是调用动态生成的代理类方法，目标类的方法已经经过了动态类的逻辑包装
            obj.findPartner();
            //obj.findHouse();
            //obj.findJob();
            //obj.shopping();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

测试结果如下：

FilePath = /Users/leitan/Worker/IdeaSpace/architect/target/classes/com/leitan/architect/pattern/proxy/mine/
class com.leitan.architect.pattern.proxy.mine.$Proxy0
媒婆：请给我你的需求,开始帮你物色…
需要肤白、貌美、大长腿的伴侣…
如果找到符合要求的就安排给你!

Process finished with exit code 0

  1. 根据上面的接口已经实现了找媳妇的动态代理，这里再把动态生成的代理类的源码贴出一下，能够看得更加清楚明白
package com.leitan.architect.pattern.proxy.mine;

import com.leitan.architect.pattern.proxy.sta.Person;
import java.lang.reflect.Method;

public class $Proxy0 implements Person {
    public MyInvocationHandler handler;

    public $Proxy0(MyInvocationHandler handler) {
        this.handler = handler;
    }

    public void findHouse() {
        try {
            Method m = Person.class.getMethod("findHouse", new Class[]{});
            this.handler.invoke(this, m, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    public void shopping() {
        try {
            Method m = Person.class.getMethod("shoping", new Class[]{});
            this.handler.invoke(this, m, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    public void findJob() {
        try {
            Method m = Person.class.getMethod("findJob", new Class[]{});
            this.handler.invoke(this, m, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }

    public void findPartner() {
        try {
            Method m = Person.class.getMethod("findPartner", new Class[]{});
            this.handler.invoke(this, m, null);
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}
飘云羽逸
关注
专栏目录
从简入繁详解代理模式（手写JDK动态代理）
dms2017的博客
11-19 915
1简单概要 代理模式：指为其他对象提供一种代理来控制对这个对象的访问。 代理模式主要有两个目的： ①保护目标对象； ②增强目标对象。 它的类图如下： 2分类与详解 2.1 静态代理 举个栗子：儿子正在找对象，而父母希望儿女早点找到另一半，于是在儿子找对象的同时帮他物色： interface Person{ void findLove(); } public class Son implements Person { public void findLo...
手写Java动态代理
0xc
12-04 913
如图1所示，动态代理的使用 这篇文章讲解动态代理的原理，以及如何手写动态代理。 以下是有关动态代理的使用，这是JDK默认帮我们实现的动态代理。 public class Main implements InvocationHandler { static Person person=new PersonImp(); public static void main(Strin...
【干货】JDK动态代理的实现原理以及如何手写一个JDK动态代理
weixin_33896069的博客
10-18 115
动态代理代理模式是设计模式中非常重要的一种类型，而设计模式又是编程中非常重要的知识点，特别是在业务系统的重构中，更是有举足轻重的地位。代理模式从类型上来说，可以分为静态代理和动态代理两种类型。在解释动态代理之前我们先理解一下静态代理：首先你要明白静态代理的作用我们有一个字体提供类，有多种实现（从磁盘，从网络，从系统）public interface FontProvider { Font ...
框架基础---动态代理
X..RH
09-21 387
代理 你有a类， 本来是调用c类的方法， 完成某个功能。 但是c不让a调用。 a -----不能调用 c的方法。 在a 和 c 直接 创建一个 b 代理，c让b访问。 a --访问b---访问c 使用代理模式的作用 1.功能增强： 在你原有的功能上，增加了额外的功能。 新增加的功能，叫做功能增强。 2.控制访问： 代理类不让你访问目标，例如商家不让用户访问厂家。 实现代理的方式 1.静态代理 ： 1） 代理类是自己手工实现的，自己创建一个java类，表示代理类。 2） 同时你所要代理的目标类是确定的。
自己写jdk动态代理及说明
gaoshan12345678910的博客
02-25 137
标准的jdk的动态代理
手写JDK动态代理
三生万物
02-16 248
JDK动态代理原理： 拿到被代理对象的引用，然后获取它的接口 JDK代理重新生成一个类，同时实现我们给的代理对象所实现的接口 把被代理对象的引用也拿到了 重新动态生成一个class字节码 然后编译 1. 获取动态生成的class文件 我们知道了JDK动态代理是动态生成java代码，然后编译、加载、执行实现的。我们如何看看JDK自动生成的java文件是怎样的呢？可以通过以下代码获取动态class...
JDK动态代理实现原理以及手写实现JDK动态代理
Chenhui98的博客
09-08 386
JDK中有一个规范，在ClassPath下只要是$开头的.class文件，一般都是自动生成的。JDK动态代理功能非常强大， 接下来就模仿JDK动态代理实现一个属于自己的动态代理。JDK动态代理采用字节重组，重新生成对象来替代原始对象，以达到动态代理的目的。要实现JDK动态代理生成对象，首先得弄清楚JDK动态代理的过程。创建的代理类是整个JDK动态代理的核心。查看生产的Java文件源代码。接口，创建属于自己的。参考JDK动态代理的。
JDK动态代理
xxyneymar的博客
10-21 126
目录 1.介绍 1.1 代理模式 1.2 代理模式的作用 1.3 实现代理的方式 2.静态代理 2.1 概述 2.2 例子 2.3 静态代理的优缺点 3.动态代理 3.1 概述 3.2 动态代理的分类 4.jdk动态代理 4.1 回顾反射中Method类 4.2 jdk动态代理的实现 4.3 实现动态代理的步骤 4.4 实例 4.5 增强功能的例子 1.介绍 动态代理是基于反射机制的，后面需要学习的mybatis、spring等底层都已经实现了动态代理功能，我们需..
代理模式：静态代理与动态代理（JDK、CGLIB、javassist动态代理）
头好重好重的博客
08-24 896
介绍代理模式中的静态代理与动态代理（JDK、CGLIB、javassist动态代理）
手写简易JDK动态代理
qq_28123419的博客
03-01 116
现在有一个需求：在执行DemoImpl类的方法前后打印日志。你如何在不修改已有代码的前提下，完成这个需求？ 当然静态代理、JDK动态代理、cglib动态代理都能实现，这里我们只用JDK动态代理实现 编写JDK动态代理基本步骤如下： 编写需要被代理的接口和类 编写代理类使用JDK自带Proxy类的newProxyInstance（）方法获取代理类 使用代理类执行目标类（被代理类）的方法 DemoInterface接口： public interface DemoInterface { void h
JDK的动态代理
诗水人间
04-11 317
JDK动态代理 如下创建动态代理对象，与cglib非常的类似 1、写一个代理类生成工厂 import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class JDKProxy implements InvocationHandler { private Object target; public JDKProxy(O
JDK实现动态代理
TSCCG的博客
09-03 444
JDK实现动态代理 思维导图：点击打开 1.代理模式概念 代理模式是指：为其他对象提供一种代理用以控制这个对象的访问。 在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户类和目标类之间起到中介的作用。——————百度百科《代理模式》 代理对象 客户端---->中介---->目标对象 生活中的例子： 房产中介 代购 媒婆 2.代理模式作用 2.1控制访问 在代理中控制客户端能否调用目标对象的方法。 比如媒婆安排相亲 2.2增强功能 完成目标对象的
如何手写一个JDK动态代理？
11-07 160
一、动态代理 代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。 为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。 二
JDK的动态代理详解
Zzzzzzz的博客
10-29 179
文章目录 JDK动态代理的实现流程： 首先创建一个接口，里面有一个基本的需求 接着创建一个实现类，重写这个需求 创建一个动态代理类， 1.里面new一个InvocationHandler，重写里面的invoke方法； 2.获取实现类的class对象中的具体方法； 3.在invoke方法中调用实现类方法，之后添加增强的方法； 4.根据Proxy方法中的newProxyInstance的方法获取接口的代理对象； 5.代理对象代理接口之后，获取接口里面的方法来实现增强的效果 具体的代码实现： //要代理的接口
【代理模式】JDK动态代理示例代码
最新发布
鹏啊鹏
07-10 1139
JDK动态代理示例代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值