Java动态代理的原理
2024-05-14 18:56:13
Java动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。下面我们开始动态代理的学习。
动态代理的简要说明
在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)。
一、 InvocationHandler(interface)的描述：
InvocationHandler is the interface implemented by the invocation handler of a proxy instance. Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用 一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
这个方法接收三个参数和返回一个Object类型，它们分别代表的意思如下：
- proxy： 指代我们所代理的那个真实对象
- method： 指代的是我们所要调用真实对象的方法的Method对象
- args： 指代的是调用真实对象某个方法时接受的参数
返回的Object是指真实对象方法的返回类型，以上会在接下来的例子中加以深入理解。
the value to return from the method invocation on the proxy instance.
二、 Proxy(Class)的描述：
Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
Proxy这个类的作用就是用来动态创建一个代理对象。我们经常使用的是newProxyInstance这个方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
参数的理解：
// 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载 loader - the class loader to define the proxy class // 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口 interfaces - the list of interfaces for the proxy class to implement // 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上 h - the invocation handler to dispatch method invocations to
返回结果的理解： 一个代理对象的实例
a proxy instance with the specified invocation handler of a proxy class that is defined by the specified class loader and that implements the specified interfaces
简单的Java代理
我们创建一个Java项目用于对动态代理的测试与理解，项目结构如下：
一、 先定义一个接口Interface，添加两个方法。
package com.huhx.proxy;public interface Interface {void getMyName();String getNameById(String id);
}
二、 定义一个真实的实现上述接口的类，RealObject：
package com.huhx.proxy;public class RealObject implements Interface {@Overridepublic void getMyName() {System.out.println("my name is huhx");}@Overridepublic String getNameById(String id) {System.out.println("argument id: " + id);return "huhx";}
}
三、 定义一个代理对象，也实现了上述的Interface接口：
package com.huhx.proxy;public class SimpleProxy implements Interface {private Interface proxied;public SimpleProxy(Interface proxied) {this.proxied = proxied;}@Overridepublic void getMyName() {System.out.println("proxy getmyname");proxied.getMyName();}@Overridepublic String getNameById(String id) {System.out.println("proxy getnamebyid");return proxied.getNameById(id);}
}
四、 SimpleMain在Main方法中，测试上述的结果：
package com.huhx.proxy;public class SimpleMain {private static void consume(Interface iface) {iface.getMyName();String name = iface.getNameById("1");System.out.println("name: " + name);}public static void main(String[] args) {consume(new RealObject());System.out.println("========================================================");consume(new SimpleProxy(new RealObject()));}
}
五、 运行的结果如下：
my name is huhx argument id: 1 name: huhx ======================================================== proxy getmyname my name is huhx proxy getnamebyid argument id: 1 name: huhx
Java的动态代理
完成了上述简单的Java代理，现在我们开始学习Java的动态代理，它比代理的思想更向前一步，因为它可以动态地创建代理并动态的处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的对策。下面我们通过案例来加深Java动态代理的理解：
一、 创建一个继承了InvocationHandler的处理器：DynamicProxyHandler
package com.huhx.dynamicproxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Arrays;public class DynamicProxyHandler implements InvocationHandler {private Object proxied;public DynamicProxyHandler(Object proxied) {System.out.println("dynamic proxy handler constuctor: " + proxied.getClass());this.proxied = proxied;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("dynamic proxy name: " + proxy.getClass());System.out.println("method: " + method.getName());System.out.println("args: " + Arrays.toString(args));Object invokeObject = method.invoke(proxied, args);if (invokeObject != null) {System.out.println("invoke object: " + invokeObject.getClass());} else {System.out.println("invoke object is null");}return invokeObject;}
}
二、 我们写一个测试的Main方法，DynamicProxyMain：
package com.huhx.dynamicproxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;import com.huhx.proxy.Interface;
import com.huhx.proxy.RealObject;public class DynamicProxyMain {public static void consumer(Interface iface) {iface.getMyName();String name = iface.getNameById("1");System.out.println("name: " + name);}public static void main(String[] args) throws Exception, SecurityException, Throwable {RealObject realObject = new RealObject();consumer(realObject);System.out.println("==============================");// 动态代理ClassLoader classLoader = Interface.class.getClassLoader();Class<?>[] interfaces = new Class[] { Interface.class };InvocationHandler handler = new DynamicProxyHandler(realObject);Interface proxy = (Interface) Proxy.newProxyInstance(classLoader, interfaces, handler);System.out.println("in dynamicproxyMain proxy: " + proxy.getClass());consumer(proxy);}
}
三、 运行结果如下：
my name is huhx argument id: 1 name: huhx ============================== dynamic proxy handler constuctor: class com.huhx.proxy.RealObject in dynamicproxyMain proxy: class com.sun.proxy.$Proxy0 dynamic proxy name: class com.sun.proxy.$Proxy0 method: getMyName args: null my name is huhx invoke object is null dynamic proxy name: class com.sun.proxy.$Proxy0 method: getNameById args: [1] argument id: 1 invoke object: class java.lang.String name: huhx
从以上输出结果，我们可以得出以下结论：
- 与代理对象相关联的InvocationHandler，只有在代理对象调用方法时，才会执行它的invoke方法
- invoke的三个参数的理解：Object proxy是代理的对象, Method method是真实对象中调用方法的Method类, Object[] args是真实对象中调用方法的参数
Java动态代理的原理
一、 动态代理的关键代码就是Proxy.newProxyInstance(classLoader, interfaces, handler)，我们跟进源代码看看：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {// handler不能为空if (h == null) {throw new NullPointerException();}final Class<?>[] intfs = interfaces.clone();final SecurityManager sm = System.getSecurityManager();if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);}/** Look up or generate the designated proxy class.*/// 通过loader和接口，得到代理的Class对象Class<?> cl = getProxyClass0(loader, intfs);/** Invoke its constructor with the designated invocation handler.*/try {final Constructor<?> cons = cl.getConstructor(constructorParams);final InvocationHandler ih = h;if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {// create proxy instance with doPrivilege as the proxy class may// implement non-public interfaces that requires a special permissionreturn AccessController.doPrivileged(new PrivilegedAction<Object>() {public Object run() {return newInstance(cons, ih);}});} else {// 创建代理对象的实例return newInstance(cons, ih);}} catch (NoSuchMethodException e) {throw new InternalError(e.toString());}
}
二、 我们看一下newInstance方法的源代码：
private static Object newInstance(Constructor<?> cons, InvocationHandler h) {try {return cons.newInstance(new Object[] {h} );} catch (IllegalAccessException | InstantiationException e) {throw new InternalError(e.toString());} catch (InvocationTargetException e) {Throwable t = e.getCause();if (t instanceof RuntimeException) {throw (RuntimeException) t;} else {throw new InternalError(t.toString());}}
}
三、 当我们通过代理对象调用 一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
体现这句话的代码，我在源码中没有找到，于是我在测试类的main方法中加入以下代码：
if (proxy instanceof Proxy) {InvocationHandler invocationHandler = Proxy.getInvocationHandler(proxy);invocationHandler.invoke(proxy, realObject.getClass().getMethod("getMyName"), null);System.out.println("--------------------------------------");
}
这段代码的输出结果如下，与上述中调用代理对象中的getMyName方法输出是一样的，不知道Jvm底层是否是这样判断的：
dynamic proxy handler constuctor: class com.huhx.proxy.RealObject dynamic proxy name: class com.sun.proxy.$Proxy0 method: getMyName args: null my name is huhx invoke object is null --------------------------------------
Java动态代理的原理相关推荐
- java高级----Java动态代理的原理
Java动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类.代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程 ...
- java 动态代理实现原理
上篇讲了:java动态代理浅析 这篇讲讲其内部实现原理. 1.相关的类和接口 1.1 java.lang.reflect.Proxy 这是 Java 动态代理机制的主类,它提供了一组静态方法来为一组 ...
- java动态代理原理及解析
转载自 http://blog.csdn.net/scplove/article/details/52451899 代理:设计模式 代理模式是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制 ...
- java动态代理实现与原理详细分析（代码层面解释了AOP的实现）
关于Java中的动态代理,我们首先需要了解的是一种常用的设计模式--代理模式,而对于代理,根据创建代理类的时间点,又可以分为静态代理和动态代理. 一.代理模式 代理模式是常用的java设计模式, ...
- java动态代理原理
代理:设计模式 代理模式是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个真实对象的访问.代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理. 通过 ...
- Java中的原生动态代理和CGLIB动态代理的原理，我不信你全知道！
作者:CarpenterLee cnblogs.com/CarpenterLee/p/8241042.html 动态代理在Java中有着广泛的应用,比如Spring AOP,Hibernate数据查询 ...
- java动态代理实现与原理详细分析（【转载】By--- Gonjan ）
[转载]By--- Gonjan 关于Java中的动态代理,我们首先需要了解的是一种常用的设计模式--代理模式,而对于代理,根据创建代理类的时间点,又可以分为静态代理和动态代理. 一.代理模式 ...
- (转）java动态代理实现与原理详细分析
https://www.cnblogs.com/gonjan-blog/p/6685611.html 1.静态代理 静态代理:由程序员创建或特定工具自动生成源代码,也就是在编译时就已经将接口,被代理类 ...
- 【java】java动态代理实现与原理详细分析
文章目录 一.代理模式 二.静态代理 1.静态代理 2.静态代理简单实现 三.动态代理 1.动态代理 2.动态代理简单实现 四.动态代理原理分析 五.总结 关于Java中的动态代理,我们首先需要了解的 ...
最新文章
- 川大网络教育2013秋《计算机应用基础》第二次作业,2013秋川大网教《计算机应用基础》第一、二次作业及答案解析.doc...
- python导入xlsx文件-python怎么用pd导入xlsx
- 与顶级互联网公司技术大佬面对面聊聊RocketMQ
- Lock和synchronized比较详解(转)
- c#设计模式学习1之工厂模式
- C++11新特性之左值右值及移动语句与完美转发
- 百度地图离线sdk java_百度地图SDK java.lang.UnsatisfiedLinkError: Couldn't load BaiduMapSDK...
- 一个 Safari 的 new Date() bug
- 学习jQuery之旅--新手必须知道的常用方法
- 宝塔搭建PHP自适应懒人网址导航源码实测
- PDMS Pipeline Tool 教程（二）：通用功能
- Lingo 11.0免费下载安装
- android开发从入门到精通 扶松柏 PDF版
- 基于ASP的高校宿舍管理系统设计与实现
- android stop 服务,当调用stopService方法时服务不会停止
- Bolt: Anonymous Payment Channels for Decentralized Currencies 学习笔记
- 小程序跳到h5页面_小程序如何跳转h5页面
- 附录002《 Git 中的重要概念》
- 【软件安装】远程桌面软件系列
- 网络与协议2022 - Practice Questions - Block 1