计划自己手写字节码而不是采用asm(完整版）

最新推荐文章于 2024-10-29 16:28:27 发布
最新推荐文章于 2024-10-29 16:28:27 发布
阅读量230 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/xiandafu/blog/219870
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

Beetl2.0 目前采用ASM来写字节码，但我发现ASM占用空间还是比较大，大约45K（压缩成jar后），如果自己手写的话，占用仅仅6K（估算的），所以打算在beetl2.0发布前，改成手写bytecode。

ByteCodeWriter实现了一个属性访问类，通过javap，内容如下 

E:\>javap -c Test.class
public class org.beetl.sample.s01.Test extends org.beetl.core.resolver.AttributeAccess {
  public org.beetl.sample.s01.Test();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method org/beetl/core/resolver/AttributeAccess."<init>":()V
       4: return


  public java.lang.Object value(java.lang.Object, java.lang.Object);
    Code:
       0: aload_1
       1: checkcast     #12                 // class org/beetl/core/User
       4: invokevirtual #14                 // Method org/beetl/core/User.getAge:()I
       7: invokestatic  #18                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      10: areturn
}


package org.beetl.core.resolver;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.beetl.core.lab.TestUser;

public class FiledAccessByteCodeWriter
{

	static final int MAGIC = 0xCAFEBABE;
	static final byte CONS_CLASS = 7;
	static final byte CONS_UTF8 = 1;
	static final byte CONS_METHODREF = 10;
	static final byte CONS_NAME_AND_TYPE = 12;
	static final byte CONS_DOUBLE = 6;

	static final short ALOAD_0 = 42;
	static final short ALOAD_1 = 43;
	static final short ALOAD_2 = 44;
	static final short INVOKE_SPECIAL = 183;
	static final short INVOKE_VIRTUAL = 182;
	static final short RETURN = 177;
	static final short ARETURN = 176;
	static final short CHECK_CAST = 192;
	static final short INVOKE_STATIC = 184;
	static final String parentCls = "org/beetl/core/resolver/AttributeAccess";
	static final String initFunction = "<init>";
	static final String initFunctionDesc = "()V";
	static final String valueFunction = "value";
	static final String valueFunctionDesc = "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;";
	static final String code = "Code";

	//outbox,inbox
	static final String integerClass = "org/beetl/core/util/NumberUtil"; //优化过的拆箱
	static final String valueOfFunction = "valueOf";
	static final String intValueOfFunctionDesc = "(I)Ljava/lang/Integer;";

	static final String shortClass = "java/lang/Short";
	static final String shortValueOfFunctionDesc = "(S)Ljava/lang/Short;";

	static final String booleanClass = "java/lang/Boolean";
	static final String booleanValueOfFunctionDesc = "(Z)Ljava/lang/Boolean;";

	static final String doubleClass = "java/lang/Double";
	static final String doubleValueOfFunctionDesc = "(D)Ljava/lang/Double;";

	static String longClass = "java/lang/Long";
	static String longValueOfFunctionDesc = "(J)Ljava/lang/Long;";

	byte[] cached = new byte[256];
	List<Object[]> constPool = new ArrayList<Object[]>();
	Map<String, Short> utfMap = new HashMap<String, Short>();
	Map<String, Short> classMap = new HashMap<String, Short>();

	String cls = "org/beetl/sample/s01/Test1";
	String targetCls = "org/beetl/core/lab/TestUser";
	String targetFunction = "getAge";
	String targetFunctionDesc = "()I";
	String retByteCodeType = "I";

	static ASMClassLoader loader = new ASMClassLoader();

	static class ASMClassLoader extends ClassLoader
	{
		public Class defineClass(String name, byte[] b)
		{
			return defineClass(name, b, 0, b.length);
		}
	}

	/**
	 * 尝试自己写bytecode代码，代替asm.jar,以缩小beetl大小
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		Class c = TestUser.class;
		String name = "contacts";
		String methodName = "getContacts";
		Class returnType = String[].class;
		FiledAccessByteCodeWriter cw = new FiledAccessByteCodeWriter(c, name, methodName, returnType);
		byte[] bs = cw.getClassByte();

		//		OutputStream ins = new FileOutputStream("e:/Test1.class");
		//		ins.write(bs);
		//		ins.close();
		TestUser user = new TestUser("joelli");
		Class fieldAccessorClass = loader.defineClass(c.getName() + "_" + name, bs);
		AttributeAccess ac = (AttributeAccess) fieldAccessorClass.newInstance();
		Object result = ac.value(user, name);
		System.out.println(result);

	}

	public FiledAccessByteCodeWriter(Class c, String name, String methodName, Class returnType)
	{
		String cname = c.getName().replace(".", "/");
		this.targetCls = cname;
		this.cls = cname + "_" + name;
		this.targetFunction = methodName;
		String[] returnArray = this.getRetrunTypeDesc(returnType);
		String returnTypeClass = returnArray[0];
		this.retByteCodeType = returnArray[1];
		this.targetFunctionDesc = "()" + returnTypeClass;

	}

	public byte[] getClassByte() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		write(out);
		return bs.toByteArray();
	}

	//	public Object getObject() throws Exception
	//	{
	//		FiledAccessByteCodeWriter cw = new FiledAccessByteCodeWriter();
	//		byte[] bs = cw.getClassByte();
	//		Class c = loader.defineClass("org.beetl.sample.s01.Test1", bs);
	//		Object o = c.newInstance();
	//
	//		return o;
	//
	//	}

	public void write(DataOutputStream out) throws Exception
	{

		//第一个占位用
		out.writeInt(MAGIC);
		out.writeShort(0);
		//jdk5
		out.writeShort(49);

		int clsIndex = this.registerClass(this.cls);
		int parentIndex = this.registerClass(this.parentCls);

		byte[] initMethod = getInitMethod();
		byte[] valueMethod = this.getProxyMethod();

		//constpool-size
		out.writeShort(this.constPool.size() + 1);
		writeConstPool(out);
		out.writeShort(33);//public class
		out.writeShort(clsIndex);
		out.writeShort(parentIndex);
		out.writeShort(0); //interface count;
		out.writeShort(0); //filed count;
		//写方法
		out.writeShort(2); //method count;
		out.write(initMethod);
		out.write(valueMethod);

		out.writeShort(0); //class-attribute-info

	}

	public void writeConstPool(DataOutputStream out) throws Exception
	{
		for (Object[] array : this.constPool)
		{
			int tag = (Byte) array[0];
			out.writeByte(tag);
			switch (tag)
			{
				case CONS_CLASS:
					out.writeShort((Short) array[1]);
					break;
				case CONS_UTF8:
					out.writeShort((Short) array[1]);
					byte[] content = (byte[]) array[2];
					out.write(content);
					break;
				case CONS_METHODREF:
					//class & nameAndType
					out.writeShort((Short) array[1]);
					out.writeShort((Short) array[2]);
					break;
				case CONS_NAME_AND_TYPE:
					//name & desc 
					out.writeShort((Short) array[1]);
					out.writeShort((Short) array[2]);
					break;
				default:
					throw new RuntimeException("tag=" + tag);

			}
		}
	}

	public byte[] getProxyMethod() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		out.writeShort(1); //public 
		int nameIndex = this.registerUTFString(this.valueFunction);
		out.writeShort(nameIndex);
		int descIndex = this.registerUTFString(this.valueFunctionDesc);
		out.writeShort(descIndex);
		out.writeShort(1); //attributeCount
		byte[] initCodeAttr = proxyCodeAttr();
		out.write(initCodeAttr);
		return bs.toByteArray();
	}

	public byte[] proxyCodeAttr() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		int index = this.registerUTFString("Code");
		out.writeShort(index);
		byte[] codes = proxyCodes();
		//属性长度
		int attrlen = 4 + 4 + codes.length + 4;
		out.writeInt(attrlen);
		if (this.retByteCodeType.equals("D") || this.retByteCodeType.equals("J"))
		{
			out.writeShort(2);
		}
		else
		{
			out.writeShort(1); //stack,default 1,long or double shoud be 2.
		}

		out.writeShort(3); //local var
		out.writeInt(codes.length);
		out.write(codes); //codes;
		out.writeShort(0); //exceptions
		out.writeShort(0); //attr-info
		return bs.toByteArray();

	}

	public byte[] proxyCodes() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		out.writeByte(ALOAD_1);

		out.writeByte(this.CHECK_CAST);
		short classIndex = this.registerClass(this.targetCls);
		out.writeShort(classIndex);

		out.writeByte(INVOKE_VIRTUAL);
		int methodIndex = registerMethod(this.targetCls, this.targetFunction, this.targetFunctionDesc);
		out.writeShort(methodIndex);

		if (this.retByteCodeType.equals("I"))
		{
			out.writeByte(INVOKE_STATIC);
			methodIndex = registerMethod(this.integerClass, this.valueOfFunction, this.intValueOfFunctionDesc);
			out.writeShort(methodIndex);
		}
		else if (this.retByteCodeType.equals("S"))
		{
			out.writeByte(INVOKE_STATIC);
			methodIndex = registerMethod(this.shortClass, this.valueOfFunction, this.shortValueOfFunctionDesc);
			out.writeShort(methodIndex);
		}
		else if (this.retByteCodeType.equals("D"))
		{
			out.writeByte(INVOKE_STATIC);
			methodIndex = registerMethod(this.doubleClass, this.valueOfFunction, this.doubleValueOfFunctionDesc);
			out.writeShort(methodIndex);
		}
		else if (this.retByteCodeType.equals("J"))
		{
			out.writeByte(INVOKE_STATIC);
			methodIndex = registerMethod(this.longClass, this.valueOfFunction, this.longValueOfFunctionDesc);
			out.writeShort(methodIndex);
		}

		out.writeByte(ARETURN - 256);
		return bs.toByteArray();

	}

	public byte[] getInitMethod() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		out.writeShort(1); //public 
		int nameIndex = this.registerUTFString("<init>");
		out.writeShort(nameIndex);
		int descIndex = this.registerUTFString("()V");
		out.writeShort(descIndex);
		out.writeShort(1); //attributeCount
		byte[] initCodeAttr = initCodeAttr();
		out.write(initCodeAttr);
		return bs.toByteArray();

	}

	public byte[] initCodeAttr() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		int index = this.registerUTFString("Code");
		out.writeShort(index);
		byte[] codes = initCodes();
		//属性长度
		int attrlen = 4 + 4 + codes.length + 4;
		out.writeInt(attrlen);
		out.writeShort(1); //stack
		out.writeShort(1); //local var
		out.writeInt(codes.length);
		out.write(codes); //codes;
		out.writeShort(0); //exceptions
		out.writeShort(0); //attr-info
		return bs.toByteArray();

	}

	public byte[] initCodes() throws Exception
	{
		ByteArrayOutputStream bs = new ByteArrayOutputStream();
		DataOutputStream out = new DataOutputStream(bs);
		out.writeByte(ALOAD_0);
		out.writeByte(INVOKE_SPECIAL);
		int index = registerMethod(this.parentCls, "<init>", "()V");
		out.writeShort(index);
		out.writeByte(RETURN - 256);
		return bs.toByteArray();

	}

	public short registerClass(String clsName)
	{
		Short index = classMap.get(clsName);
		if (index != null)
			return index;
		short clsNameIndex = registerUTFString(clsName);
		Object[] array = new Object[]
		{ this.CONS_CLASS, clsNameIndex };
		this.constPool.add(array);
		index = getCurrentIndex();
		classMap.put(clsName, index);
		return index;
	}

	public short registerMethod(String clsName, String method, String desc)
	{

		short clsNameIndex = this.registerClass(clsName);
		short nameAndTypeIndex = registerNameAndType(method, desc);

		Object[] array = new Object[]
		{ this.CONS_METHODREF, clsNameIndex, nameAndTypeIndex };
		this.constPool.add(array);
		return getCurrentIndex();
	}

	public short registerNameAndType(String method, String desc)
	{
		short nameIndex = registerUTFString(method);
		short descIndex = registerUTFString(desc);
		Object[] array = new Object[]
		{ this.CONS_NAME_AND_TYPE, nameIndex, descIndex };
		this.constPool.add(array);
		return getCurrentIndex();
	}

	public short registerUTFString(String str)
	{
		Short index = this.utfMap.get(str);
		if (index != null)
			return index;
		try
		{
			byte[] bs = str.getBytes("UTF-8");
			short len = (short) bs.length;
			Object[] array = new Object[]
			{ CONS_UTF8, len, bs };
			this.constPool.add(array);
			index = getCurrentIndex();
			this.utfMap.put(str, index);
			return index;
		}
		catch (UnsupportedEncodingException e)
		{
			//not happen
			throw new RuntimeException(e);
		}

	}

	public short getCurrentIndex()
	{
		return (short) (this.constPool.size());
	}

	private String[] getRetrunTypeDesc(Class c)
	{
		StringBuilder sb = new StringBuilder();
		String returnType = "";
		if (c.isArray())
		{
			sb.append(c.getName().replace(".", "/"));
		}
		else if (c == int.class)
		{
			sb.append("I");
			returnType = "I";
		}
		else if (c == boolean.class)
		{
			sb.append("Z");
			returnType = "Z";
		}
		else if (c == char.class)
		{
			sb.append("C");
			returnType = "C";
		}
		else if (c == short.class)
		{
			sb.append("S");
			returnType = "S";
		}
		else if (c == float.class)
		{
			sb.append("F");
			returnType = "F";
		}
		else if (c == long.class)
		{
			sb.append("J");
			returnType = "J";
		}
		else if (c == double.class)
		{
			sb.append("D");
			returnType = "D";
		}
		else
		{
			sb.append("L").append(c.getName().replace(".", "/")).append(";");
			returnType = "L";
		}
		return new String[]
		{ sb.toString(), returnType };
	}
}



转载于:https://my.oschina.net/xiandafu/blog/219870

weixin_34126557
关注
从C++转成JS的那些事
新兴IT民工的专栏
08-26 3681
前言JS的一些硬伤与尝试是编译还是解释变量是动态还是静态asm.jswasmLLVM编译过程与LLVM关于两种编译器和的小历史顺带了解一下的ASTWebAssemblyEmscripten记录下emscripten的安装过程构建系统工具对wasm的支持V8引擎nodeJS 前言 最近接触到了不少前端的技术，作为一个老的C++程序员，了解到竟然可以把C++代码直接编译成JS在前端运行感觉到不可思议，于是就跳入了这个大坑。 从我这个老的C++程序员的理解顺序来说，我是从如下几个方面去了解整个webas
第 04 章：崭露头角，基于Cglib实现含构造函数的类实例化策略
bugstack虫洞栈
05-31 6198
作者：小傅哥 博客：https://bugstack.cn 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 技术成长，是对场景设计细节不断的雕刻！ 你觉得自己的技术什么时候得到了快速的提高，是CRUD写的多了以后吗？想都不要想，绝对不可能！CRUD写的再多也只是能满足你作为一个搬砖工具人，敲击少逻辑流水代码的速度而已，而编程能力这一块，除了最开始的从不熟练到熟练以外，就很少再有其他提升了。 那你可能会想什么才是编程能力提升？其实更多的编程能力的提升是你对复杂场景的架构把控以及对每一个技术
字节码实战--手写一个btrace
u014493323的博客
07-05 127
简易的btrace需求 偶现的方法执行慢，我们是可以用jstack捕捉到的，但是慢到什么地步却是不一定知道的，现在就需要在不重启应用的情况下，获取方法执行的时间。 需求特点 应用不重启 获取方法执行时间 技术选型 想要打印出时间，起码想到的是aop的方式。常规的方法是必须重启应用才能加的，...
自己实现字节码增强
sky_100的博客
06-27 517
使用技术：Javassist ， Instrument，JVMTI , javaagent，Attach API JVMTI：JVM TI(JVM TOOL INTERFACE，JVM 工具接口)是 JVM 提供的一套对 JVM 进行操作的工具接口。通过 JVMTI，可以实现对 JVM 的多种操作，它通过接口注册 各种事件勾子，在 JVM 事件触发时，同时触发预定义的勾子，以实现对各个 JVM 事件的响应，事件包括类文件加载、异常产生与捕获、线程启动和结束、进入和退 出临界区、成员变量修改、GC 开始和结束
手写 Class 字节码解析技术（一）
吴小智的理想流
07-24 813
上章节写到关于java热部署功能的技术点，简单的阐述了关于类加载的问题，既然了解到了class这个知识点了，那就不能不刨根问底的对class解析一番。看看能不能完成一个类似于ASM、Javassist之类的java字节码操纵功能。 Class文件是一组以8位字节为基础单位的二进制流，当遇到需要8位字节以上空间的数据项时，则会按照高位在前的方式分隔成若干个8位字节进行存储。各项按照严格...
硬核手写字节码实现HelloWorld
麒思妙想
09-01 532
这是一篇硬（闲的）核（蛋疼）的文章，我们来通过手写字节码的方式，来完成一个Helloworld。起因很简单，最近在看《深入理解JVM字节码》，尝试了解读class文件，但是总觉得不过瘾，...
框架手写系列---Asm方式实现日志插入
双斧狂暴战专栏
09-27 1147
asm与javassist作为修改字节码文件的两种常用方式，在编译过程中，可以动态修改class字节码文件。前文已用javassist方式实现热修复的前置步骤，本文用asm实现动态的给每个activity插入Log日志。 一、插件的生成与依赖导入 1、用该文章中的方法：Android中Plugin插件工程的自动生成自动生成一个android的插件模板； 2、加入asm依赖，加入依赖后的插件build的格式如下： dependencies{ compile gradleApi() ..
【Java编译器后端技术】：字节码生成与优化，让你的代码更高效
Java编译器后端是Java程序运行的关键环节，它的主要工作是将中间表示（IR）转换成可以在JVM上运行的字节码。这个过程包含了多个阶段，如代码优化、字节码生成和链接等。理解Java编译器后端对于Java性能优化、自定义...
三年开发经验, 字节跳动抖音组离职后, 一口气拿到 15 家公司 Offer
m0_64384350的博客
11-28 2402
先聊了聊为什么离开现在公司，毕竟现在这么火 我做的项目中的一些解决方案，组件化、字节码注入、包体积的极致优化 直播的架构设计 三面 设计一个上传日志的大小，涉及到，性能、文件大小、怎样压缩、时机、TopK 问题等聊了聊在字节跳动做的事情 总结 是一家创业公司，给的薪资还是挺不错的，但是由于是 996，没有加班工资，多出来的钱可能就是加班工资吧，后面听 hr 说公司正在打算取消 996 2 公司：探探 是通过脉脉上网红马映怡推荐的，马映怡之前在字节跳动，今年 4 月份到了探探，在脉脉找到了我，..
手写Spring事务框架，阿里架构师一文详解Spring-SpringAOP原理
Java_supermanNO1的博客
01-03 668
本文转载自：手写Spring事务框架，阿里架构师一文详解Spring-SpringAOP原理 一、Spring核心知识 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性...
深入理解JVM总结——虚拟机字节码执行引擎
nalanmingdian的博客
08-21 444
执行引擎是Java虚拟机最核心的组成部分之一。物理机和虚拟机都有执行代码的能力。区别在于物理机的执行引擎是直接建立在处理器、硬件、指令集和操作系统层面上的，而虚拟机的执行引擎则是由自己实现的，因此可以自行指定指令集与执行引擎的结构体系，并且能够执行那些不被硬件直接支持的指令集格式。 虚拟机执行引擎在执行Java代码的时候分为解释执行（通过解释器执行）和编译执行（通过即时编译器产生本地代码执行），也
Java字节码框架 -- Javassist
carl.zhao的专栏
09-02 2399
Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码JBoss 应用服务器项目，通过使用Javassist对字节码操作为JBoss实现动态”AOP”框架。
学会阅读Java字节码
网站开发初中级代码参考-转载
09-04 340
1.Class文件基础 （1）文件格式 Class文件的结构不像XML等描述语言那样松散自由。由于它没有任何分隔符号， 所以，以上数据项无论是顺序还是数量都是被严格限定的。哪个字节代表什么 含义，长度是多少，先后顺序如何，都不允许改变。 （2）数据类型 仔细观察上面的Class文件格式，可以看出Class文件格式采用一种类似于C语言 结构体的伪结构来存储，...
手写 Class 字节码解析技术（三）手写 Aspectj实现aop 一
吴小智的理想流
06-29 499
说到AOP ，我想大家是再熟悉不过。AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
Class字节码指令解释执行
Fouy_风度玉门。
09-17 4156
JVM指令主要包含了一下几种类型：加载和存储指令、运算指令、类型转换指令、对象创建与访问指令、操作数栈管理指令、控制转移指令、方法调用和返回指令、异常处理指令、同步指令等。 基于栈的解释器执行过程         下面看一下一个简单的代码片段，如下所示： public class StackTest { public int calc() { int a = 100; int
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
最新发布
h2345678的博客
10-29 1266
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1047
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 512
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1235
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
ASM4：Java字节码操作框架详解
然而，ASM以其最新的特性和高效的性能脱颖而出，为开发者提供了一个强大而灵活的字节码操作平台。ASM库的使用者可以根据需要创建自定义的类加载器，实现诸如动态代理、AOP切面、运行时代码生成等复杂功能。 在ASM4...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值