java 动态代理深度学习(Proxy,InvocationHandler)

2024-02-18 00:18
文章标签 java 动态 学习 深度 代理 proxy invocationhandler

本文主要是介绍java 动态代理深度学习(Proxy,InvocationHandler)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

http://hi.baidu.com/malecu/item/9e0edc115cb597a1feded5a0

http://www.iteye.com/topic/683613

http://blog.csdn.net/zsmj_2011/article/details/10394805

http://www.ibm.com/developerworks/cn/java/j-lo-hibernatelazy/index.html?ca=dat

通常情况下，适用代理模式的情况有两种：

1.创建对象开销很大，可以创建一个代理对象，推迟真正的对象创建。大家所熟悉的Hibernate延迟加载策略就是使用动态代理，当A实体关联B实体时，在获取A实体时不需要立即获得与A实体关联的B实体，因为有可能客户端根本不需要B实体数据，当客户端真正需要这部分数据时，再加载B实体的数据。这样就节省了资源。

2.所创建的对象不能满足客户端需求，比如说我们需要为某个方法运行前加入一些验证或者过滤，这时我们就需要创建一个代理对象，增强原来对象的功能。


代理模式

代理模式是一种应用非常广泛的设计模式，当客户端代码需要调用某个对象时，客户端实际上也不关心是否准确得到该对象，它只要一个能提供该功能的对象即可，此时我们就可返回该对象的代理（Proxy）。

在这种设计方式下，系统会为某个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个 Java 对象代表另一个 Java 对象来采取行动。在某些情况下，客户端代码不想或不能够直接调用被调用者，代理对象可以在客户和目标对象之间起到中介的作用。

对客户端而言，它不能分辨出代理对象与真实对象的区别，它也无须分辨代理对象和真实对象的区别。客户端代码并不知道真正的被代理对象，客户端代码面向接口编程，它仅仅持有一个被代理对象的接口。

总而言之，只要客户端代码不能或不想直接访问被调用对象——这种情况有很多原因，比如需要创建一个系统开销很大的对象，或者被调用对象在远程主机上，或者目标对象的功能还不足以满足需求……，而是额外创建一个代理对象返回给客户端使用，那么这种设计方式就是代理模式。

下面示范一个简单的代理模式，程序首先提供了一个 Image 接口，代表大图片对象所实现的接口，该接口代码如下：

清单 3. Image.java
 public interface Image { void show(); }

该接口提供了一个实现类，该实现类模拟了一个大图片对象，该实现类的构造器使用 Thread.sleep() 方法来暂停 3s。下面是该 BigImage 的程序代码。

清单 4. BigImage.java
 // 使用该 BigImage 模拟一个很大图片public class BigImage implements Image { public BigImage() { try { // 程序暂停 3s 模式模拟系统开销 Thread.sleep(3000); System.out.println("图片装载成功 ..."); } catch (InterruptedException ex) { ex.printStackTrace(); } } // 实现 Image 里的 show() 方法public void show() { System.out.println("绘制实际的大图片"); } }

上面的程序代码暂停了 3s，这表明创建一个 BigImage 对象需要 3s 的时间开销——程序使用这种延迟来模拟装载此图片所导致的系统开销。如果不采用代理模式，当程序中创建 BigImage 时，系统将会产生 3s 的延迟。为了避免这种延迟，程序为 BigImage 对象提供一个代理对象，BigImage 类的代理类如下所示。

清单 5. ImageProxy.java
 public class ImageProxy implements Image { // 组合一个 image 实例，作为被代理的对象private Image image; // 使用抽象实体来初始化代理对象public ImageProxy(Image image) { this.image = image; } /** * 重写 Image 接口的 show() 方法* 该方法用于控制对被代理对象的访问，* 并根据需要负责创建和删除被代理对象*/ public void show() { // 只有当真正需要调用 image 的 show 方法时才创建被代理对象if (image == null) { image = new BigImage(); } image.show(); } }

上面的 ImageProxy 代理类实现了与 BigImage 相同的 show() 方法，这使得客户端代码获取到该代理对象之后，可以将该代理对象当成 BigImage 来使用。

在 ImageProxy 类的 show() 方法中增加了控制逻辑，这段控制逻辑用于控制当系统真正调用 image 的 show() 时，才会真正创建被代理的 BigImage 对象。下面程序需要使用 BigImage 对象，但程序并不是直接返回 BigImage 实例，而是先返回 BigImage 的代理对象，如下面程序所示。

清单 6. BigImageTest.java
 public class BigImageTest { public static void main(String[] args) { long start = System.currentTimeMillis(); // 程序返回一个 Image 对象，该对象只是 BigImage 的代理对象Image image = new ImageProxy(null); System.out.println("系统得到 Image 对象的时间开销 :" + (System.currentTimeMillis() - start)); // 只有当实际调用 image 代理的 show() 方法时，程序才会真正创建被代理对象。image.show(); } }

上面程序初始化 image 非常快，因为程序并未真正创建 BigImage 对象，只是得到了 ImageProxy 代理对象——直到程序调用 image.show() 方法时，程序需要真正调用 BigImage 对象的 show() 方法，程序此时才真正创建 BigImage 对象。运行上面程序，看到如图 6 所示的结果。

图 6. 使用代理模式提高性能
图 6. 使用代理模式提高性能

看到如图 6 所示的运行结果，读者应该能认同：使用代理模式提高了获取 Image 对象的系统性能。但可能有读者会提出疑问：程序调用 ImageProxy 对象的 show() 方法时一样需要创建 BigImage 对象啊，系统开销并未真正减少啊？只是这种系统开销延迟了而已啊？

我们可以从如下两个角度来回答这个问题：

  • 把创建 BigImage 推迟到真正需要它时才创建，这样能保证前面程序运行的流畅性，而且能减少 BigImage 在内存中的存活时间，从宏观上节省了系统的内存开销。
  • 有些情况下，也许程序永远不会真正调用 ImageProxy 对象的 show() 方法——意味着系统根本无须创建 BigImage 对象。在这种情形下，使用代理模式可以显著地提高系统运行性能。

与此完全类似的是，Hibernate 也是通过代理模式来“推迟”加载关联实体的时间，如果程序并不需要访问关联实体，那程序就不会去抓取关联实体了，这样既可以节省系统的内存开销，也可以缩短 Hibernate 加载实体的时间。



java 动态代理深度学习,

一.相关类及其方法:

java.lang.reflect.Proxy,
Proxy 提供用于创建动态代理类和实例的静态方法.
newProxyInstance()
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
(详见api文档)

java.lang.reflect.InvocationHandler,
InvocationHandler 是代理实例的调用处理程序 实现的接口。 
invoke()
在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
(详见api文档)

二.源代码:

被代理对象的接口及实现类:
package com.ml.test;

public interface Manager {
public void modify();
}

package com.ml.test;

public class ManagerImpl implements Manager {

@Override
public void modify() {
   System.out.println("*******modify()方法被调用");
}
}

业务代理类:
package com.ml.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class BusinessHandler implements InvocationHandler {

private Object object = null;

public BusinessHandler(Object object) {
   this.object = object;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
   System.out.println("do something before method");
   Object ret = method.invoke(this.object, args);
   System.out.println("do something after method");
   return ret;

}
}



客户端类:
package com.ml.test;
import java.lang.reflect.Proxy;
public class Client {

public static void main(String[] args) {
   // 元对象(被代理对象)
   ManagerImpl managerImpl = new ManagerImpl();

   // 业务代理类（在元对象的基础上增加内容，比如这个函数运行需要时间，调试信息等）
   BusinessHandler securityHandler = new BusinessHandler(managerImpl);

   // 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
   Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
     .getClass().getClassLoader(), managerImpl.getClass()
     .getInterfaces(), securityHandler);

   managerProxy.modify();
}
}


managerImpl是被代理的类的对象，Manager是其接口类

securityHandler是代理managerImpl的对象，也就是说mnagerImpl是在securityHandler中以其成员变量的形式存在

Proxy.newProxyInstance()，传入securityHandler对象，生成一个新类$Proxy0, securityHandler对象作为其的一个成员变量，这个新类实现了Manager接口，对于接口的每一个方法都是调用securityHandler的invoke函数，在invoke函数中调用的是managerImpl的对应的方法。生成$Proxy0的对象，就是Mangager managerPorxy.


如果是RPC模式的，怎么用代理呢？

由newProxyInstance()生成的代理类，其中成员变量就是继承了InvocationHandler的类的对象，对于这个代理类，就可以看做是远程服务器类(被代理类)的在本地的一个实例，完全可以把本地实例就看做是远程服务器的实例，对于这个实例的每次函数的调用，就是把这次调用的函数名和参数传给invoke函数，由invoke函数内部实现网络通讯，就是把函数名和参数发给远程服务器，服务器接收之后，把运行结果通过网络返回


三.执行结果:
do something before method
*******modify()方法被调用
do something after method

四.机制分析:

Proxy.(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy.
$Proxy0类实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下:
class Proxy{
   InvocationHandler h=null;
   protected Proxy(InvocationHandler h) {
    this.h = h;
   }
   ...
}



下面是本例的$Proxy0类的源码(好不容易才把它提出来):


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Manager {

private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
   try {
    m1 = Class.forName("java.lang.Object").getMethod("equals",
      new Class[] { Class.forName("java.lang.Object") });
    m0 = Class.forName("java.lang.Object").getMethod("hashCode",
      new Class[0]);
    m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
      new Class[0]);
    m2 = Class.forName("java.lang.Object").getMethod("toString",
      new Class[0]);
   } catch (NoSuchMethodException nosuchmethodexception) {
    throw new NoSuchMethodError(nosuchmethodexception.getMessage());
   } catch (ClassNotFoundException classnotfoundexception) {
    throw new NoClassDefFoundError(classnotfoundexception.getMessage());
   }
}

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

@Override
public final boolean equals(Object obj) {
   try {
    return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
      .booleanValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final int hashCode() {
   try {
    return ((Integer) super.h.invoke(this, m0, null)).intValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

public final void modify() {
   try {
    super.h.invoke(this, m3, null);
    return;
   } catch (Error e) {
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final String toString() {
   try {
    return (String) super.h.invoke(this, m2, null);
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}
}

接着把得到的$Proxy0实例强制转换成Manager.
当执行managerProxy.modify()方法时,就调用了$Proxy0类中的modify()方法.
在modify方法中,调用父类Proxy中的h的invoke()方法.
即InvocationHandler.invoke();


/*** 相亲接口* * @author zhengt* @time Jun 3, 2095 3:13:03 PM*/
public interface XiangQinInterface {/*** 相亲方法*/public void xiangQin();
}
/*** 张三相亲实现类* * @author zhengt* @time Jun 3, 2095 3:14:48 PM*/
public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {public void xiangQin() {System.out.println("张三去相亲，娶个漂亮老婆。");}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。* * @author zhengt* @time Jun 3, 2095 3:15:48 PM*/
public class ReadyInvocationHandler implements InvocationHandler {//相亲接口的实现类，也就是张三相亲类private Object zhangSan = null;public ReadyInvocationHandler(Object realSubject) {this.zhangSan = realSubject;}public Object invoke(Object proxy, Method m, Object[] args) {Object result = null;try {/*** 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，* 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，* 也就是ReadyInvocationHandler类的invoke方法。* 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0，* 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。*//*** 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道，* 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了*/System.out.println(proxy.getClass().getSimpleName());System.out.println("张三相亲前，代理人给他打扮了打扮。");result = m.invoke(zhangSan, args);} catch (Exception ex) {System.exit(1);}return result;}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** 张三来到了婚介所(相亲现场)，开始相亲。* * @author zhengt* @time Jun 3, 2095 3:17:16 PM*/
public class HunJieSuo {public static void main(String args[]) {//先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();/*** 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。* 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，* 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，* 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,* 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法*//*** 在java种怎样实现动态代理呢* 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，* 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。* 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，* 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，* 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。* 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。*/XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan));proxy.xiangQin();/*** 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？* 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和* zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口* 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)* 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。* 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。* 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，* 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类* 方法执行前后做额外工作的类ReadyInvocationHandler。* 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))* 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。* 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。*/}
}



这篇关于java 动态代理深度学习(Proxy,InvocationHandler)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/719433。

相关文章

Java Predicate接口定义详解

Java Predicate接口定义详解

《JavaPredicate接口定义详解》Predicate是Java中的一个函数式接口,它代表一个判断逻辑,接收一个输入参数,返回一个布尔值,：本文主要介绍JavaPredicate接口的定义... 目录Java Predicate接口Java lamda表达式 Predicate<T>、BiFuncti
阅读更多...
Spring Security基于数据库的ABAC属性权限模型实战开发教程

Spring Security基于数据库的ABAC属性权限模型实战开发教程

《SpringSecurity基于数据库的ABAC属性权限模型实战开发教程》：本文主要介绍SpringSecurity基于数据库的ABAC属性权限模型实战开发教程,本文给大家介绍的非常详细,对大... 目录1. 前言2. 权限决策依据RBACABAC综合对比3. 数据库表结构说明4. 实战开始5. MyBA
阅读更多...
Spring Security方法级安全控制@PreAuthorize注解的灵活运用小结

Spring Security方法级安全控制@PreAuthorize注解的灵活运用小结

《SpringSecurity方法级安全控制@PreAuthorize注解的灵活运用小结》本文将带着大家讲解@PreAuthorize注解的核心原理、SpEL表达式机制,并通过的示例代码演示如... 目录1. 前言2. @PreAuthorize 注解简介3. @PreAuthorize 核心原理解析拦截与
阅读更多...
一文详解JavaScript中的fetch方法

一文详解JavaScript中的fetch方法

《一文详解JavaScript中的fetch方法》fetch函数是一个用于在JavaScript中执行HTTP请求的现代API,它提供了一种更简洁、更强大的方式来处理网络请求,：本文主要介绍Jav... 目录前言什么是 fetch 方法基本语法简单的 GET 请求示例代码解释发送 POST 请求示例代码解释
阅读更多...
Java图片压缩三种高效压缩方案详细解析

Java图片压缩三种高效压缩方案详细解析

《Java图片压缩三种高效压缩方案详细解析》图片压缩通常涉及减少图片的尺寸缩放、调整图片的质量(针对JPEG、PNG等)、使用特定的算法来减少图片的数据量等,：本文主要介绍Java图片压缩三种高效... 目录一、基于OpenCV的智能尺寸压缩技术亮点：适用场景：二、JPEG质量参数压缩关键技术：压缩效果对比
阅读更多...
Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
springboot+dubbo实现时间轮算法

springboot+dubbo实现时间轮算法

《springboot+dubbo实现时间轮算法》时间轮是一种高效利用线程资源进行批量化调度的算法,本文主要介绍了springboot+dubbo实现时间轮算法,文中通过示例代码介绍的非常详细,对大家... 目录前言一、参数说明二、具体实现1、HashedwheelTimer2、createWheel3、n
阅读更多...
详解nginx 中location和 proxy_pass的匹配规则

详解nginx 中location和 proxy_pass的匹配规则

《详解nginx中location和proxy_pass的匹配规则》location是Nginx中用来匹配客户端请求URI的指令,决定如何处理特定路径的请求,它定义了请求的路由规则,后续的配置（如... 目录location 的作用语法示例：location /www.chinasem.cntestproxy
阅读更多...
Java利用docx4j+Freemarker生成word文档

Java利用docx4j+Freemarker生成word文档

《Java利用docx4j+Freemarker生成word文档》这篇文章主要为大家详细介绍了Java如何利用docx4j+Freemarker生成word文档,文中的示例代码讲解详细,感兴趣的小伙伴... 目录技术方案maven依赖创建模板文件实现代码技术方案Java 1.8 + docx4j + Fr
阅读更多...
SpringBoot首笔交易慢问题排查与优化方案

SpringBoot首笔交易慢问题排查与优化方案

《SpringBoot首笔交易慢问题排查与优化方案》在我们的微服务项目中,遇到这样的问题：应用启动后,第一笔交易响应耗时高达4、5秒,而后续请求均能在毫秒级完成,这不仅触发监控告警,也极大影响了用户体... 目录问题背景排查步骤1. 日志分析2. 性能工具定位优化方案：提前预热各种资源1. Flowable
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2