动态代理

最新推荐文章于 2024-11-06 17:05:50 发布
最新推荐文章于 2024-11-06 17:05:50 发布
阅读量256 收藏 3
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CoderPOPO/article/details/89046241
版权

一.动态代理

动态代理的作用:就是在不破坏已经写好的类的情况下,去增强其中某些方法的功能,比如在调用方法之前或之后,做一些额外的操作.(像权限校验,等)

动态代理的两种实现:

       1.根据接口实现的动态代理(JDK)

       2.根据类实现的动态代理(CGLIB)

二.JDK中的proxy-使用

1.先创建需要被代理的接口--其中eat()方法

public interface IEat {

    public void eat(Apple apple);

}

2.再创建类去实现该方法--打印一段话

public class Eat implements IEat{
    @Override
    public void eat(Apple apple) {
        System.out.println("I eat a "+apple.getColor()+" "+apple.getName());
    }
}

3.创建Apple类--参数类

public class Apple {

    private String name;

    private String color;

    public Apple(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

4.创建一个xxhandler 去实现 InvocationHandler--实现invoke方法

public class AppleHandler implements InvocationHandler {

    private Object target;

    // 传入需要被代理的对象,获得增强后的对象
    public <T> T getInstance(Object target) throws Exception {
        this.target = target;
        Class<?> targetClass = target.getClass();
        return (T) Proxy.newProxyInstance(targetClass.getClassLoader(), targetClass.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用原有方法之前,进行调用(比如:权限控制,或者打印入参日志等)
        before();
        // 调用原有方法
        Object obj = method.invoke(this.target, args);
        // 在调用原有方法之后,进行调用(比如:打印出参日志,数据库回滚或提交操作等)
        after();
        return obj;
    }

    private void before() {
        System.out.println("洗苹果");
    }

    private void after() {
        System.out.println("吃完了");
    }
}

5.创建一个测试类进行测试

public class Test {

    public static void main(String[] args) throws Exception {
        IEat ie = new Eat();
        ie.eat(new Apple("apple","red"));

        System.out.println("============================");

        // 获取加载地址,获取类接口,再获取重写后的增强方法,返回一个增强类
        IEat obj = new AppleHandler().getInstance(new Eat());
        obj.eat(new Apple("apple","red"));

    }
}

6.测试结果---可以看出,并未对原有IEat接口,Eat类,Apple类,进行更改,但采用代理方式,却多做了一些处理

三.JDK中的proxy-分析

1.我们去生成一下代理类(利用ProxyGenerator.generateProxyClass()进行代理类生成),再用反编译去查看下代理类的具体情况

public class Test {

    public static void main(String[] args) throws Exception {
        IEat ie = new Eat();
        ie.eat(new Apple("apple","red"));

        System.out.println("============================");

        // 获取加载地址,获取类接口,再获取重写后的增强方法,返回一个增强类
        IEat obj = new AppleHandler().getInstance(new Eat());
        obj.eat(new Apple("apple","red"));

        //$Proxy0
            byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IEat.class});
            FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
            os.write(bytes);
            os.close();
    }
}

2.代理类的具体情况--(精简化后)

import com.gper.vip.homework.proxy.Apple;
import com.gper.vip.homework.proxy.IEat;
import java.lang.reflect.*;

public final class $Proxy0 extends Proxy implements IEat{

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

    // 实现eat()方法
    public final void eat(Apple apple){
        try{
            // 其中的 h ,其实就为传入invocationhandler
            // 就是调用的invocationhandler中的invoke(this, m3, new Object[] { apple })方法
            super.h.invoke(this, m3, new Object[] { apple });
            return;
        }catch(Error _ex) { 
        }catch(Throwable throwable){
            throw new UndeclaredThrowableException(throwable);
        }
    }

    private static Method m3;

    static {
        try{
            // 获取IEat中的eat方法
            m3 = Class.forName("com.gper.vip.homework.proxy.IEat").getMethod("eat", new Class[] {
                Class.forName("com.gper.vip.homework.proxy.Apple")
            });
        }catch(NoSuchMethodException nosuchmethodexception){
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }catch(ClassNotFoundException classnotfoundexception){
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}

从上述代理类中可以看出,

1.proxy其实就是通过,新生成一个代理类($Proxy0)去继承IEat接口,实现eat()方法.

2.而在代理类在eat()方法中,去调用的是InvocationHandler.invoke()方法,而InvocationHandler是通过代理类的构造函数传入的

3.而InvocationHandler,就是Proxy.newProxyInstance(targetClass.getClassLoader(), targetClass.getInterfaces(), this);

    就是上面我们生成代理类时,传入的this,也就是我们写好的AppleHandler

4.调用逻辑 $Proxy0.eat()-->AppleHandler.invoke()-->Eat.eat()

   所以我们就可以在AppleHandler.invoke()中增强,接下来需要调用的Eat.eat()方法了

四.仿照JDK中的proxy-进行编写

1.首先进行Proxy.newProxyInstance的编写,整体逻辑为:
    a.动态生成源文件-(targetClass.getInterfaces())
    b.生成Java文件输出到磁盘
    c.将生成的java文件编译成.class文件
    d.把编译成的.class文件加载到jvm中
    e.返回通过字节码重组以后生成的新的代理对象

建立一个MyProxy并且创建一个newProxyInstance(MyClassLoader loader, Class<?>[] interf, MyInvocationHandler h)方法

public class MyProxy {

    private static final String ln = "\r\n";

    public static Object newProxyInstance(MyClassLoader myClassloader, Class<?>[] interfaces, MyInvocationHandler h) throws Exception {
        // 1.动态生成源文件
        String str = generateEatSrc(interfaces);
        // 2.Java文件输出到磁盘
        String filePath = MyProxy.class.getResource("").getPath();
        File file = new File(filePath + "$Proxy0.java");
        FileWriter fileWriter = new FileWriter(file);
        fileWriter.write(str);
        fileWriter.flush();
        fileWriter.close();
        // 3.把生成的.java文件编译成.class文件
        JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager standardJavaFileManager = javaCompiler.getStandardFileManager(null, null, null);
        Iterable it = standardJavaFileManager.getJavaFileObjects(file);

        JavaCompiler.CompilationTask task = javaCompiler.getTask(null, standardJavaFileManager, null
                , null, null, it);

        task.call();
        standardJavaFileManager.close();

        // 4.把编译成的.class文件加载到jvm中
        Class proxyClass = myClassloader.findClass("$Proxy0");
        // 5.返回字节码重组以后生成新的代理对象
        Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
        file.delete();
        return c.newInstance(h);
    }

    // 比较low的方法,直接按照代理类进行拼接,写死了
    private static String generateEatSrc(Class<?>[] interfaces) {
        StringBuffer sb = new StringBuffer();
        sb.append("package com.gper.vip.homework.proxy.myproxy;" + ln);
        sb.append("import com.gper.vip.homework.proxy.Apple;" + ln);
        sb.append("import com.gper.vip.homework.proxy.IEat;" + ln);
        sb.append("import java.lang.reflect.*;" + ln);
        sb.append("public final class $Proxy0 implements "+interfaces[0].getName()+"{" + ln);
        sb.append("    MyInvocationHandler h;" + ln);
        sb.append("    public $Proxy0(MyInvocationHandler h){" + ln);
        sb.append("        this.h=h;" + ln);
        sb.append("    }" + ln);
        sb.append("    public final void eat(Apple apple){" + ln);
        sb.append("        try{" + ln);
        sb.append("            h.invoke(this, m3, new Object[] {apple});" + ln);
        sb.append("            return;" + ln);
        sb.append("        }" + ln);
        sb.append("        catch(Error _ex) { }" + ln);
        sb.append("        catch(Throwable throwable){ throw new UndeclaredThrowableException(throwable);}" + ln);
        sb.append("    }" + ln);
        sb.append("    private static Method m3;" + ln);
        sb.append("    static {" + ln);
        sb.append("        try{" + ln);
        sb.append("            m3 = Class.forName(\"com.gper.vip.homework.proxy.Eat\").getMethod(\"eat\", new Class[] {" + ln);
        sb.append("                Class.forName(\"com.gper.vip.homework.proxy.Apple\")});" + ln);
        sb.append("        }catch(NoSuchMethodException nosuchmethodexception){" + ln);
        sb.append("            throw new NoSuchMethodError(nosuchmethodexception.getMessage());" + ln);
        sb.append("        }catch(ClassNotFoundException classnotfoundexception){" + ln);
        sb.append("            throw new NoClassDefFoundError(classnotfoundexception.getMessage());" + ln);
        sb.append("        }" + ln);
        sb.append("    }" + ln);
        sb.append("}" + ln);
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        IEat ie = (IEat) new MyAppleHandler().getInstance(new Eat());
        ie.eat(new Apple("apple", "red"));
    }
}

2.再创建一个MyClassLoader类,继承ClassLoader(由于需要用到defineClass()方法,而自己又写不出),并重写findClass()方法

defineClass就是将将一个byte数组实例化成一个类类型

public class MyClassLoader extends ClassLoader {

    private File classPathFile;

    public MyClassLoader(){
        // 获取MyClassLoader所在本地文件地址
        String classPath = MyClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    // 找到.class文件,并将其加载进来
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 拼接类的全类名
        String className = MyClassLoader.class.getPackage().getName()+"."+name;
        // 获取类文件所在磁盘位置
        File file = new File(classPathFile,name+".class");
        // 读取类文件,并写入缓存中
        FileInputStream in = null;
        ByteArrayOutputStream out = null;
        try{
            in = new FileInputStream(file);
            out = new ByteArrayOutputStream();
            byte[] buff = new byte[1024];
            int len;
            while((len = in.read(buff))!= -1){
                out.write(buff,0,len);
            }
            // Converts an array of bytes into an instance of class <tt>Class</tt>
            return defineClass(className,out.toByteArray(),0,out.size());
        }catch (Exception e){

        }
            return null;
    }
}

3.创建一个MyInvocationHandler接口

public interface MyInvocationHandler {

    // 代理对象,方法,参数
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException, Exception;
}

4.创建一个MyAppleHandler去实现MyInvocationHandler接口

public class MyAppleHandler implements MyInvocationHandler {


    private Object target;

    public Object getInstance(Object target) throws Exception {
        this.target = target;
        Class<?> targetClass = target.getClass();
        // 使用MyProxy , MyClassLoader , MyInvocationHandler 去生成代理类
        return MyProxy.newProxyInstance(new MyClassLoader(), targetClass.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        befor();
        Object invoke = method.invoke(this.target, args);
        after();
        return invoke;
    }

    private void after() {
        System.out.println("执行方法之后...");
    }

    private void befor() {
        System.out.println("执行方法之前....");
    }

}

5.运行测试方法

    public static void main(String[] args) throws Exception {
        IEat ie = (IEat) new MyAppleHandler().getInstance(new Eat());
        ie.eat(new Apple("apple", "red"));
    }

6.测试结果--还原JDK的proxy功能

从上述就能看出整条逻辑线为:

1.通过传入的interfaces,myInvocationHandler参数,经过反射+拼接字符串,生成代理类(一长串字符串)

   a.代理类实现了--需要被代理类所实现的接口,以及在实现的接口方法中,调用的是myInvocationHandler.invoke()方法

   b.代理类只有一个有参构造(必须传MyInvocationHandler)

2.将(一长串字符串)输出到磁盘上,形成.java文件

3.再使用javaCompile将.java文件编译成.class文件

4.再将.class加载到jvm中

5.再到jvm中找到加载的代理类,并通过有参构造函数初始化(传入MyAppleHandler)一个代理类并返回该代理类

五.关于JDK动态代理源码中要求目标类实现的接口数量不能超过65535个的问题？

答:是和Class类文件的结构中的接口计数器有关,接口计数器是u2类型,u2又是2个字节的,16位,最大就是2^16-1=65535 ,因为超过65535时,接口技术器就爆掉了,所以动态代理中要求目标类实现的接口数量不能超过65535个~

参考-类文件结构

CoderPOPO
关注
专栏目录
手机网页错误101解析及解决方法
CyberLynxO的博客
10-05 4989
手机网页错误101是指在使用手机浏览器访问网页时出现的错误。该错误通常表示服务器无法找到或连接到请求的网页。使用其他浏览器或设备：如果使用的是默认浏览器，尝试切换到其他浏览器或使用其他设备访问网页，以确定问题是否与特定的浏览器或设备有关。希望本文的解析和解决方法能帮助您理解和解决手机网页错误101。如果问题仍然存在，请考虑联系网页的管理员或寻求进一步的技术支持。网页不存在：当用户请求的网页在服务器上不存在时，将返回错误101。刷新页面：有时候错误101可能是暂时的问题，刷新页面可以尝试重新加载网页。
JDK动态代理实现原理
z69183787的专栏
12-06 3427
地址：http://rejoy.iteye.com/blog/1627405 之前虽然会用JDK的动态代理，但是有些问题却一直没有搞明白。比如说：InvocationHandler的invoke方法是由谁来调用的，代理对象是怎么生成的，直到前几个星期才把这些问题全部搞明白了。      废话不多说了，先来看一下JDK的动态是怎么用的。  Java代码   p
小程序预加载数据实战
qq_42700121的博客
05-24 3876
最近抖音很火的一个摸鱼办提醒，提示各个假期的倒计时间，收到了很多打工人的追捧。当时我就想到可以把这个界面写成一个小程序，动态的展示时间和倒计时，其中倒计时数据是从服务端获得，需要加载时间，导致页面延迟加载，体验效果差。 小程序延迟效果 假期倒计时的界面大体如下： 上下部分都是固定的，中间每个节假日都是从服务端动态获取数据，所以会出现节假日倒计时延迟加载的情况： 可以看出，页面加载时，中间的节假日会出现延迟渲染的情况，为了解决这个问题，需要用到小程序的数据预拉取。 解决方案：数据预拉取 小程序为了提升.
APNS和Background Fetch相关问题总结
pwf2006的博客
05-19 2738
APNS和Background Fetch相关问题总结 1.1 Normal Push Notification1.1.1 概述1.1.2 deviceToken相关1.1.3 推送feedback接口1.1.4 badge点击不消失的问题1.1.5 定制push notification的推送时间段1.1.6 push notification的功能扩展1.1.7 收不到push notification的情况总结1.1.8 测试工具1.2 Silent Push Notification1.2.1 概述
微信小程序 errno“:1001,“errMsg“:“previewImage:fail parameter error: parameter.urls[0] s
qq_27806371的博客
07-08 1161
微信小程序 errno":1001,"errMsg":"previewImage:fail parameter error: parameter.urls[0] s
qt qtableview动态代理
09-14
然而，QTableView的功能可以进一步增强，通过实现动态代理（Dynamic Proxy）来扩展其交互性。动态代理允许我们在表格的单元格内嵌入其他UI元素，比如QSpinBox、QCheckBox或QComboBox，从而提供更丰富的用户交互体验...
小程序授权登录报错 errno:112
weixin_41752213的博客
01-16 1226
调用wx.getUserProfile进行授权时，遇到112报错。
打开小程序报101
webZRH的博客
08-31 1376
打开小程序报101
微信小程序报错之backgroundfetch privacy fail
qq_60208156的博客
03-25 6110
微信公众平台 ==> 设置 ==>服务内容声明 ==> 更新。审核通过后就可正常使用了！在调用接口的时候就会弹出弹窗。
微信小程序报错WAServiceMainContext.js:1 [wxapplib]] backgroundfetch privacy fail {“errno“:101,怎么解决？！
最新发布
z445803550的博客
11-06 415
1.小程序未在 app.json 文件中声明使用特定功能：您需要确保在 app.json 文件的 “permissions” 字段中添加了相应权限，例如 “ibeacon” 权限。2.用户隐私协议中未声明小程序使用此功能：如果小程序需要使用某些功能，您需要在微信公众平台的服务内容声明中更新，声明小程序使用的功能。最后，我打算付费找淘宝大佬帮忙解决一下的时候，我在想电脑可以那后端没问题，权限都全了，那是不是配置的问题，最终你猜是啥原因？“desc”: “你的位置信息将用于小程序位置接口的效果展示”
为什么JDK动态代理中要求目标类实现的接口数量不能超过65535个
阿浩的博客
07-11 2913
先明确几个概念： Class文件是一组以8字节为基础单位的二进制流 各个数据项目严格按照顺序紧凑排列在class文件中 中间没有任何分隔符，这使得class文件中存储的内容几乎是全部程序运行的程序 Java虚拟机规范规定，Class文件格式采用类似C语言结构体的伪结构来存储数据，这种结构只有两种数据类型：无符号数和表 接口索引计数器(interfaces_count)，占2字节 参考第一句话：cl...
java + 动态代理 + 动态代理实际应用场景
04-28
1：静态代理出现的实际背景，静态代理时如何演化成动态代理 2： 动态代理demo 举例实际应用场景（载入数据库驱动的时候，使用AIDL与系统Servic进行通信） 3: 动态代理使用到基础理论：ClassLoader 加载.class字节码...
细说JDK动态代理的实现原理
徐泗空的博客
12-26 522
关于JDK的动态代理，最为人熟知要可能要数spring AOP的实现，默认情况下，Spring AOP的实现对于接口来说就是使用的JDK的动态代理来实现的，而对于类的代理使用CGLIB来实现。那么，什么是JDK的动态代理呢？ JDK的动态代理，就是在程序运行的过程中，根据被代理的接口来动态生成代理类的class文件，并加载运行的过程。JDK从1.3开始支持动态代理。那么JDK是如何生成动态代
JDK动态代理与运行时织入字节码
u010061691的专栏
03-11 3121
java jdk动态代理其实是动态生成字节码与反射机制的一个结合，说到反射机制很多人都用到过反射，只要得到对应类的Class对象即可，调用方法，获取成员变量等等，那么jdk的动态代理就是在程序运行的过程中，动态的将我们维护的检查性的代码，放在正常的业务代码之前，那么怎么调用我正常的业务代码呢，因为业务可能有很多种，也就是说可能会有不同的类，但是都要执行相同的检查性代码，如我们要取钱，或者是修改身份
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值