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。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2