AsmSupport缺陷还真多

最新推荐文章于 2024-10-10 09:56:47 发布
最新推荐文章于 2024-10-10 09:56:47 发布
阅读量110 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/woate/blog/379532
版权

AsmSupport缺陷还真多，本来打算用于TalkingBird的直接本地代码执行引擎的开发，没想到AsmSupport存在动态绑定的缺陷，通过修正AsmSupport底层实现解决动态绑定，结果又出现栈溢出。甚是让人奔溃。

怎么解决动态绑定的问题呢？

首先我们要搞清楚如下代码是否是合理的： 


import java.io.Serializable;

import org.junit.Test;

public class Test1 {
	@Test
	public void test1(){
		byte b = 1;
		fun(b);
	}
	public void fun(byte i){//①
		System.out.println("byte");
	}
	public void fun(short i){//②
		System.out.println("short");
	}
	public void fun(int i){//③
		System.out.println("int");
	}
	public void fun(long i){//④
		System.out.println("long");
	}
	public void fun(float i){//⑤
		System.out.println("float");
	}
	public void fun(double i){//⑥
		System.out.println("double");
	}
	public void fun(Byte i){//⑦
		System.out.println("Byte");
	}
	public void fun(Serializable i){//⑧
		System.out.println("Serializable");
	}
	public void fun(Object i){//⑨
		System.out.println("Object");
	}
}


相信大家都知道运行结果输出byte.

那么这样呢，注掉①的函数重载。

结果是short，结果还是可以理解，Java自动对原生类型进行拓展。


那么注掉从①——⑥,结果都是能够理解的。但是注掉⑦后，结果就费解了，结果居然是Serializable，却不是我们熟知的Object。原来是因为包装类实现了序列化接口，直到最后才是Object。

其他基本数据类型依次逻辑递推，注意short之后是int，不是char。

char的拓展类型是int，特别注意，short不能拓展到char。


对于拆箱呢。

则依据如下顺序，包装类->Serializable->Object->对应原生数据类型。

要解决AsmSupport的缺陷，必须重写cn.wensiqun.asmsupport.utils.AClassUtils#GetDirectSuperType()方法在获取父类的逻辑。 

/**
	 * 获取一个给定的类的超类<br>
	 * boolean:boolean->Boolean->Serializable->Object<br>
	 * byte:byte->short->int->long->float->double->Byte->Serializable->Object<br>
	 * short:short->int->long->float->double->Short->Serializable->Object<br>
	 * char:char->int->long->float->double->Character->Serializable->Object<br>
	 * int:int->long->float->double->Integer->Serializable->Object<br>
	 * long:long->float->double->Long->Serializable->Object<br>
	 * float:float->double->Float->Serializable->Object<br>
	 * double:double->Double->Serializable->Object<br>
	 * Serializable:Serializable->Object<br>
	 * 拆箱发生在最后<br>
	 * Boolean:Boolean->Serializable->Object->boolean<br>
	 * Byte:Byte->Serializable->Object->byte<br>
	 * Short:Short->Serializable->Object->short<br>
	 * Character:Character->Serializable->Object->char<br>
	 * Integer:Integer->Serializable->Object->int<br>
	 * Long:Long->Serializable->Object->long<br>
	 * Float:Float->Serializable->Object->float<br>
	 * Double:Double->Serializable->Object->double<br>
	 * 如果是object无父类<br>
	 * 如果是接口获取所有父接口<br>
	 * 如果是是数组:<br>
	 * int[]: int[] -> Serializable ->Cloneable->Object 如果有超类，延继承链获取所有超类和接口<br>
	 * 
	 * @param aclass
	 *            传入的类
	 * @param autoWrapper
	 *            是否允许自动装箱
	 * @return
	 */
	public static AClass[] getDirectSuperType(AClass as) {
		AClass[] a = null;
		// 如果是原生数据类型
		if (as.isPrimitive()) {
			if (as.equals(AClass.BOOLEAN_ACLASS)) {
				a = new AClass[] { AClass.BOOLEAN_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };
			} else if (as.equals(AClass.BYTE_ACLASS)) {
				a = new AClass[] { AClass.SHORT_ACLASS, AClass.INT_ACLASS, AClass.LONG_ACLASS, AClass.FLOAT_ACLASS, AClass.DOUBLE_ACLASS, AClass.BYTE_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.SHORT_ACLASS)) {
				a = new AClass[] { AClass.INT_ACLASS, AClass.LONG_ACLASS, AClass.FLOAT_ACLASS, AClass.DOUBLE_ACLASS, AClass.SHORT_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.CHAR_ACLASS)) {
				a = new AClass[] { AClass.INT_ACLASS, AClass.LONG_ACLASS, AClass.FLOAT_ACLASS, AClass.DOUBLE_ACLASS, AClass.CHARACTER_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.INT_ACLASS)) {
				a = new AClass[] { AClass.LONG_ACLASS, AClass.FLOAT_ACLASS, AClass.DOUBLE_ACLASS, AClass.INTEGER_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.LONG_ACLASS)) {
				a = new AClass[] { AClass.FLOAT_ACLASS, AClass.DOUBLE_ACLASS, AClass.LONG_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.FLOAT_ACLASS)) {
				a = new AClass[] { AClass.DOUBLE_ACLASS, AClass.FLOAT_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };

			} else if (as.equals(AClass.DOUBLE_ACLASS)) {
				a = new AClass[] { AClass.DOUBLE_WRAP_ACLASS, AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS };
			}
			return a;
		} else if (as.equals(AClass.BOOLEAN_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.BOOLEAN_ACLASS };
			return a;
		} else if (as.equals(AClass.BYTE_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.BYTE_ACLASS };
			return a;
		} else if (as.equals(AClass.SHORT_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.SHORT_ACLASS };
			return a;
		} else if (as.equals(AClass.CHARACTER_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.CHAR_ACLASS };
			return a;
		} else if (as.equals(AClass.INTEGER_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.INT_ACLASS };
			return a;
		} else if (as.equals(AClass.LONG_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.LONG_ACLASS };
			return a;
		} else if (as.equals(AClass.FLOAT_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.FLOAT_ACLASS };
			return a;
		} else if (as.equals(AClass.DOUBLE_WRAP_ACLASS)) {
			a = new AClass[] { AClass.SERIALIZABLE_ACLASS, AClass.OBJECT_ACLASS, AClass.DOUBLE_ACLASS };
			return a;
		} else if (as.equals(AClass.SERIALIZABLE_ACLASS)) {// 如果传入的是序列化接口，则有父类Object
			a = new AClass[] { AClass.OBJECT_ACLASS };
			return a;
		} else if (as.equals(AClass.OBJECT_ACLASS)) {// 如果传入的是Object，则没有父类
			a = new AClass[0];
			return a;
		} else if (as.isInterface()) {// 如果是接口
			Class<?>[] intfacs = as.getInterfaces();
			if (intfacs != null && intfacs.length > 0) {
				AClass[] interfaceAClassArr = new AClass[intfacs.length];
				List<AClass> list = new ArrayList<AClass>();
				for (int i = 0; i < intfacs.length; i++) {
					interfaceAClassArr[i] = AClassFactory.getProductClass(intfacs[i]);
					list.add(interfaceAClassArr[i]);
				}
				// 因为Java规范不支持平行接口的重载
				// for (AClass interAClass: interfaceAClassArr) {
				// AClass[] aclassArr = getDirectSuperType(interAClass, true);
				// for (AClass aClass : aclassArr) {
				// list.add(aClass);
				// }
				// }

				list.add(AClass.OBJECT_ACLASS);
				a = list.toArray(new AClass[list.size()]);
			} else {
				a = new AClass[] { AClass.OBJECT_ACLASS };
			}
			return a;
		} else if (as.isArray()) {// 如果是数组,当组件为原生数据类型则获取克隆接口和序列化接口；否则获取组件的所有父类
			ArrayClass ac = (ArrayClass) as;
			AClass rootType = ac.getRootComponentClass();

			if (rootType.isPrimitive()) {
				a = new AClass[3];
				a[0] = AClass.SERIALIZABLE_ACLASS;
				a[1] = AClass.CLONEABLE_ACLASS;
				a[2] = AClass.OBJECT_ACLASS;
				return a;
			} else {
				AClass[] rootSupers = getDirectSuperType(rootType);// 获取组件的超类，构建数组的超类数组
				if (rootSupers != null) {// 如果组件存在超类
					a = new AClass[rootSupers.length];
					for (int i = 0; i < a.length; i++) {
						a[i] = AClassFactory.getArrayClass(rootSupers[i], ac.getDimension());
					}
					return a;
				} else {// 如果组件不存在超类，则使用克隆接口和序列化接口
					a = new AClass[3];
					a[0] = AClass.SERIALIZABLE_ACLASS;
					a[1] = AClass.CLONEABLE_ACLASS;
					a[2] = AClass.OBJECT_ACLASS;
					return a;
				}
			}
		} else {// 如果都不是，则开始延继承链寻找
			Class<?> sup = as.getSuperClass();

			Class<?>[] intefaces = as.getInterfaces();
			List<AClass> list = new ArrayList<AClass>();
			AClass supAClass = null;
			// 只有当父类不是Object才增加
			if (sup != Object.class) {
				supAClass = AClassFactory.getProductClass(sup);
				list.add(supAClass);
			}
			for (Class clazz : intefaces) {
				if (clazz != Object.class) {
					AClass interfaceAClass = AClassFactory.getProductClass(clazz);
					list.add(interfaceAClass);
				}
			}
			//有除了Object的父类
			if (supAClass != null) {
				AClass[] superAClassArr = getDirectSuperType(supAClass);
				// 任何类都有Object这个父类
				for (AClass aClass : superAClassArr) {
					if (aClass.equals(AClass.OBJECT_ACLASS)) {
						continue;
					} else {
						if (!list.contains(aClass)) {
							list.add(aClass);
						}
					}
				}
			}
			list.add(AClass.OBJECT_ACLASS);
			a = list.toArray(new AClass[list.size()]);
			return a;
		}

	}



通过以上修改可以正确找出对应的动态绑定方法。

转载于:https://my.oschina.net/woate/blog/379532

chixia3043
关注
AsmSupport：支持格式和语法突出显示（大多数）汇编代码
02-19
AsmSupport的特性还包括： 1. 自动缩进：帮助保持代码的整洁和对齐。 2. 代码折叠：可以折叠和展开代码块，便于查看和管理大型汇编程序。 3. 智能感知：提供代码补全建议，减少手动输入错误。 4. 错误检查：检测...
redhat7.5安装Oracle12cASMlib工具包
10-13
在REDHAT7.5环境中亲测安装ASM所需的rpm包，包括kmod-oracleasm-2.0.8-21.0.1.el7.x86_64.rpm,oracleasmlib-2.0.12-1.el7.x86_64.rpm,oracleasm-support-2.1.11-2.el7.x86_64.rpm
探索ASMSupport：一款强大的Android ASM库
gitblog_00063的博客
04-06 421
探索ASMSupport：一款强大的Android ASM库 项目地址:https://gitcode.com/wensiqun/asmsupport 项目简介 在软件开发领域，ASM是一个流行的目标字节码操纵和分析框架，常用于Java代理、AOP（面向切面编程）等场景。而ASMSupport项目则是针对Android环境优化的ASM库，它为开发者提供了更简便的方法来处理Android应用的字节码...
ASMSupport教程1:简单的HelloWorld
weixin_34265814的博客
03-22 158
2019独角兽企业重金招聘Python工程师标准>>> ...
ASMSupport原理概要
Small Warm www.wensiqun.com
06-11 157
ASMSupport是基于ASM实现的一套框架。 ASMSupport通过将ASM字节码操作抽象成对象记作Operator，然后将字节码操作所需要的信息封装到Operator中，并将Operator添加到执行队列Queue中，当方法所需要的所有操作都创建完毕则使用ASM框架将队列中的所有Operator执行。下面列举一个HelloWorld?例子： [code="java"] publ...
新版ASMSupport使用教程
weixin_34217773的博客
03-26 251
2019独角兽企业重金招聘Python工程师标准>>> ...
AsmSupport研究心得(五)
02-22 97
条件判断 If-then判断 /** * If-then判断 */ @Test public void testIfThen() { Cla...
ASMSupport
疯狂的代码
07-28 533
当使用ASM编写的时候 很多情况下需要了解JVM底层的指令的， 并且需要对栈和本地变量显式的进行操作， 如果直接用ASM进行开发势必会付出更多的学习成本和时间成本，并且不易后期的维护。此框架正好缓解了上述问题。是程序员编写字节码的时候更易于理解和开发，屏蔽了JVM指令以及栈和本地变量的操作，开发的时候更趋近与直接编写java程序。目前不支持注解，内部类，泛型。所以在进行List等操作的时候，需要将
ASMSupport教程2动态生成类
Small Warm www.wensiqun.com
06-28 180
在上一篇文章中我们介绍了如何生成接口，这次我们将编写如何生成一个Class，首先我们先看下面的代码：   public class CreateClassExample { private static String staticGlobalVariable = "I'm a static global variable at class"; public int gl...
基于Java和CSS优化的asmSupport框架设计源码
10-03
本项目为基于Java和CSS优化的asmSupport框架设计源码，共包含511个Java源文件、35个Markdown文档、10个XML配置文件、2个Git忽略文件、1个YAML配置文件、1个JIRA注释文件，以及1个UML图。asmSupport框架旨在简化ASM...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 948
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 1012
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1281
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 378
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 713
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
央顺科技官方博客
10-08 1516
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
Java中的break、continue和return语句
weixin_73230994的博客
10-05 384
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 606
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1122
2024最新Java面试题，针对一些小厂，中厂
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值