上篇文章我们学习了如何自己实现一个动态代理,这篇文章我们从源码角度来分析下JDK的动态代理
先看一个Demo:
public class MyInvocationHandler implements InvocationHandler {
private MyService target;
public MyInvocationHandler(MyService target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(target, args);
System.out.println("proxy invoke");
if (method.getReturnType().equals(Void.TYPE)) {
return null;
} else {
System.out.println(invoke);
return invoke+"proxy";
}
}
}
public interface MyService {
void test01();
void test02(String s);
}
public class MyServiceImpl implements MyService {
@Override
public void test01() {
System.out.println("test01");
}
@Override
public void test02(String s) {
System.out.println(s);
}
}
main方法:
public class Main {
public static void main(String[] args) {
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
proxyInstance.test01();
proxyInstance.test02("test02");
}
}
我们运行Debug观察下生成的proxyInstance
对象:
可以得出以下几个结论:
$Proxy0
MyInvocationHandler
对象这里我们越过不重要的代码,直接端点到java.lang.reflect.Proxy.ProxyClassFactory#apply
这个方法,
我们分段分析这个方法的代码(简单的代码我们就直接跳过了):
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
这段代码主要是为了确保类加载器对这个class文件解析后得到的是同一个对象。如果我们要确保两个对象相等的话,那么它们的类加载器必定是一样的。
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
这段代码主要是在判断接口是否是public的,如果不是public的那么需要将代理类生成在接口同名的包下。否则生成的代理类在com.sun.proxy
包下。
这里我们可以做一个验证:
$Proxy0
,如下:// 接口换为包访问权限
interface MyService {
void test01();
void test02(String s);
}
新建一个类,类名为$Proxy0
public static void main(String[] args) {
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
// 加载这个类到JVM中
$Proxy0 proxy0 = new $Proxy0();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
proxyInstance.test01();
proxyInstance.test02("test02");
}
运行后发现报错:显示有重复的类定义
Exception in thread "main" java.lang.LinkageError: loader (instance of sun/misc/Launcher$AppClassLoader): attempted duplicate class definition for name: "com/dmz/proxy/target/$Proxy0"
at java.lang.reflect.Proxy.defineClass0(Native Method)
at java.lang.reflect.Proxy.access$300(Proxy.java:228)
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:642)
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:557)
at java.lang.reflect.WeakCache$Factory.get(WeakCache.java:230)
at java.lang.reflect.WeakCache.get(WeakCache.java:127)
at java.lang.reflect.Proxy.getProxyClass0(Proxy.java:419)
at java.lang.reflect.Proxy.newProxyInstance(Proxy.java:719)
at com.dmz.proxy.target.Main.main(Main.java:14)
从上面我们就验证了,如果不是public的那么需要将代理类生成在接口同名的包下
接下来我们验证,正常情况下,代理类会被生成在com.sun.proxy
包下
com.sun.proxy.$Proxy0
至此,证明完毕。我们继续看代码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
// 省略部分代码......
我们可以看到,通过ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags)
生成一个字节流后,直接调用了defineClass0(…)方法,而且我们跟踪这个方法可以发现,这是一个本地方法。并且它直接返回了一个Class对象。
private static native Class<?> defineClass0(ClassLoader loader, String name,
byte[] b, int off, int len);
回顾我们上一篇文章的实现思路:
对比后我们可以发现,我们自己实现时,是通过生成java文件,然后进行编译生成class文件,再将其加载到JVM中得到class对象。而对于jdk动态代理,直接通过一个字节流调用本地方法后直接生成class对象。
我们再回过头去看下jdk是如何给我们生成这个字节流的,这里我们主要关注sun.misc.ProxyGenerator#generateClassFile
这个方法,这里我就不贴代码了。因为也是一些字符串的拼接动作,然后写入到一个字节流中,我们关注下最后生成的这个字节流是什么样子的,我们将其写入到一个文件中:
MyServiceImpl target = new MyServiceImpl();
Class<? extends MyServiceImpl> clazz = target.getClass();
MyService proxyInstance = (MyService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces()
, new MyInvocationHandler(target));
byte[] bytes = ProxyGenerator.generateProxyClass("proxy", clazz.getInterfaces());
File file = new File("G:\\com\\dmz\\proxy\\proxy.class");
FileOutputStream outputStream = new FileOutputStream(file);
outputStream.write(bytes);
proxyInstance.test01();
proxyInstance.test02("test02");
我们将得到的这个class文件放入idea反编译:
public final class proxy extends Proxy implements MyService {
private static Method m1;
private static Method m4;
private static Method m2;
private static Method m3;
private static Method m0;
public proxy(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{
var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void test01() throws {
try {
super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final void test02(String var1) throws {
try {
super.h.invoke(this, m3, new Object[]{
var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m4 = Class.forName("com.dmz.proxy.target.MyService").getMethod("test01");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.dmz.proxy.target.MyService").getMethod("test02", Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
观察上面代码,我们可以发现以下几点:
代理类继承了Proxy
这个类,正因为如此,所以jdk动态代理只能实现基于接口的代理,而不能实现对整个类进行代理,因为java是单继承的。那么为什么代理类一定要继承Proxy
这个类呢?我们可以发现代理类并没有使用Proxy
中的什么属性或者方法(虽然使用了InvocationHandler对象,但是也可以在生成class之初就将InvocationHandler放入到代理类中)。所以实际上不进行继承也是没有任何关系的。查了很多资料后发现,找到一个比较合理的解释如下:
JDK的动态代理只允许动态代理接口是设计使然,因为动态代理一个类存在一些问题。在代理模式中代理类只做一些额外的拦截处理,实际处理是转发到原始类做的。这里存在两个对象,代理对象跟原始对象。如果允许动态代理一个类,那么代理对象也会继承类的字段,而这些字段是实际上是没有使用的,对内存空间是一个浪费。因为代理对象只做转发处理,对象的字段存取都是在原始对象上处理。更为致命的是如果代理的类中有final的方法,动态生成的类是没法覆盖这个方法的,没法代理,而且存取的字段是代理对象上的字段,这显然不是我们希望的结果。spring aop框架就是这种模式。
总结起来主要两点
我们在进行代理时,实际的方法执行逻辑仍然是交给目标类处理,这个时候代理类持有目标类中的字段只不过是对内存空间的一种浪费,其余没有任何作用。
即使我们能接受对内存空间的浪费,然而如果我们在代理对象中操作代理对象中的字段,目标对象的字段不受任何影响,这显然也是不合理的。
如果是基于继承实现代理,那么有final的方法的情况下,无法完成对final方法的代理。
代理类实现了我们目标对象实现的接口,所以说JDK动态代理是基于接口实现的。
代理对象不仅仅是对接口中的方法进行了代理,还对hashCode,equals,toString三个方法进行了代理,这也是为了覆盖目标类中的所有方法
至此,我们就完成对JDK动态代理的学习!喜欢的同学点个赞吧~~~~
文章浏览阅读299次。同上一篇一样,这边摸鱼笔记也是关于分类和回归分支的权重设计。Mutual Supervision for Dense Object Detection(ICCV2021)阅读笔记_mutual supervision for dense object detection
文章浏览阅读354次,点赞5次,收藏4次。探索DLT645:一种智能电表通讯协议的实现项目地址:https://gitcode.com/WKJay/DLT645在能源管理领域,尤其是在智能家居和工业自动化中,高效、准确的数据采集至关重要。DLT645 是一个专注于实现中国国家标准GB/T 18039.2-2008的开源库,它提供了一种与智能电表进行通讯的标准化方式。通过这个项目,开发者可以轻松地整合智能电表数据到他们的应用中。项目简..._645协议智能电表采集
摘要:本文介绍了通过Host碰撞来找到隐藏业务的方法,通过配置域名字典进行碰撞,成功复现了2条数据。
文章浏览阅读1.4k次,点赞3次,收藏8次。【课程目标】打造一个简单实用的 SAP FIORI 入门开发课程,帮助广大 SAP 技术人员或者希望进入 SAP 技术领域的人打开一扇门。【课程形式】视频教程 + PDF 参考资料【学习门槛】零门槛,无需任何额外知识【作者微信】eksbobo【如何入群】使用购买课程的 ID 作为请求信息,发送到作者的微信添加好友,作者会把您拉入到这门课程的微信群中。..._sap fiori开发视频教程--由浅入深学习fiori开发
文章浏览阅读232次。启发式合并(dsu),树上启发式合并(dsu on tree)总结_启发式合并
文章浏览阅读9.1k次,点赞12次,收藏30次。当我们的 Java 对象在响应前端,或者在做数据导出的时候,我们并不希望将对象中为 null 的属性值直接返回给前端,不然显示或导出的就是一个 null ,这样对用户不是很友好。如果我们一个个字段的去处理,这样不但增加了人力,而且使得代码中逻辑冗余,显得不够优雅。于是下面我写了一个通用方法:将对象中的 String 类型属性的null 值转换为空字符串的方法,具体代码如下:/** * 把对象中的 String 类型的null字段,转换为空字符串 * * @param <.._null值转换为空字符串
文章浏览阅读7.4k次,点赞11次,收藏45次。Apollo 携程Apollo配置中心目录导航 携程 Apollo 配置中心 | 学习笔记(一) | Apollo配置中心简单介绍 携程 Apollo 配置中心 | 学习笔记(二) | Windows 系统搭建基于携程Apollo配置中心单机模式 携程 Apollo 配置中心 | 学习笔记(三) | 自..._apollo分布式配置黑马学习笔记
文章浏览阅读1.1k次,点赞16次,收藏25次。人工智能 (AI) 是对人类智慧行为的仿真。它通常是设计用来感知环境、了解行为并采取行动的一台计算机或一个系统。想想自动驾驶汽车:此类 AI 驱动系统将机器学习和深度学习等 AI 算法集成到支持自动化技术的复杂环境。据麦肯锡预计,到 2030 年,AI 的全球经济价值将高达 13 万亿美元。这是因为在 AI 浪潮的影响下,几乎各行各业乃至每一个应用领域的工程环节都在转型。除了自动驾驶以外,AI 还广泛应用于以下领域:机器故障预测模型,告知何时需要进行机器保养;健康和传感器分析,如病患监护系统;
文章浏览阅读1.8k次,点赞3次,收藏8次。VueRouter安装和使用vue-router安装模块化中使用使用vue-router的步骤使用history模式router-link重定向/默认路由点击事件跳转路由动态路由路由懒加载路由嵌套参数传递(一)路由元信息全局导航守卫前置全局后置钩子组件内守卫路由独享的守卫keep-alive注意URL:协议://主机:端口/路径?查询(query)所有的组件都继承自Vue类的原型打包:npm run buildredirect:[ˌriːdəˈrekt ] 重定向replace:没有返回箭头_router及vue-router教程
文章浏览阅读641次。这种连接方式实际上是将路由器作为一个普通的网络交换机来使用_路由器为啥插lan口为什么还能上网
文章浏览阅读293次。vue-quill-editor默认的图片插入方式,是直接将图片转成base64编码,这样的结果是整个富文本的html片段十分冗余。我们的服务器端接收的post的数据大小都是有限制的,这样的话导致提交失败,就算不提交失败,大量的数据存入数据库也不是好事。为了解决这个问题,我考虑了两个方案,换一个富文本编辑框框架,另一个是修改vue-quill-editor的框架代码。..._vue中使用el-upload自定义editor
文章浏览阅读125次。HTML/CSS常见的三种水平居中方式_htmlcss水平居中