The performance comparison of JiteScript framework and Java library
The performance comparison of JiteScript framework and Java library
introduce:
Jitescript is a Java class library based on bytecode operation, which aims to provide a simple and efficient way to generate Java bytecode.During the development process, we often need to dynamically generate class or modify existing behaviors. At this time, we can use JiteScript to achieve this.This article will compare the performance of the JiteScript framework with the commonly used Java class libraries so that readers can make wise decisions when choosing a suitable tool.
Introduction to JiteScript framework:
Jitescript is a lightweight Java class library that provides simple API to generate Java bytecode.It uses a dynamic bytecode to generate technology, which can generate the bytecode of the class by programming.By using Jitescript, we can control the structure, methods and fields of the code control class, and dynamically modify the existing classes.This dynamic generation ability is very useful in some scenarios, such as AOP (facing face -to -face programming) and code generation.
Java class library Introduction:
The Java class library refers to a set of reuse Java components for a specific field, which provides various functions and tools to enable developers to develop applications more conveniently.Common Java libraries include Apache Commons, Google Guava, Joda-Time, etc.These class libraries provide rich functions, such as collective operations, date time processing, string processing, etc.
Performance contrast analysis:
In order to compare the performance of the JITESCRIPT framework and the Java class library, we will test them in terms of generating class, modification and calling methods.We will use Java Microbenchmark Harness (JMH) tool for the benchmark test.
1. Class generate performance:
We tested the use of JiteScript framework and commonly used Java libraries to generate the same performance.First of all, we use the JiteScript framework to generate a simple Person class through the API programming method, and then use the CGLIB and byte Buddy in the Java class library to generate the same Person class, respectively.It is found that the performance of the JiteScript framework in class generation is better than the Java library.
The following is a sample code for generating the Person class with the Jitescript framework:
public class JitescriptExample {
public static void main(String[] args) throws Exception {
// Create ClassWriter
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
// Define the class name, interface and parent class
cw.visit(V1_8, ACC_PUBLIC, "com/example/Person", null, "java/lang/Object", null);
// Definition fields
cw.visitField(ACC_PRIVATE, "name", "Ljava/lang/String;", null, null).visitEnd();
// Define the structure method
MethodVisitor constructor = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
constructor.visitCode();
constructor.visitVarInsn(ALOAD, 0);
constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
constructor.visitInsn(RETURN);
constructor.visitMaxs(1, 1);
constructor.visitEnd();
// Define the getName method
MethodVisitor getName = cw.visitMethod(ACC_PUBLIC, "getName", "()Ljava/lang/String;", null, null);
getName.visitCode();
getName.visitVarInsn(ALOAD, 0);
getName.visitFieldInsn(GETFIELD, "com/example/Person", "name", "Ljava/lang/String;");
getName.visitInsn(ARETURN);
getName.visitMaxs(1, 1);
getName.visitEnd();
// Generate the byte code and load the class
byte[] bytecode = cw.toByteArray();
Class<?> clazz = new ByteArrayClassLoader().defineClass("com.example.Person", bytecode);
// Use generated classes
Object person = clazz.getDeclaredConstructor().newInstance();
Method getNameMethod = clazz.getMethod("getName");
System.out.println(getNameMethod.invoke(person));
}
}
2. Class modification performance:
We tested the use of JiteScript framework and Java class library to modify existing performance.We will use the JiteScript framework and the Java class library to add one or more methods to the Person class, and compare their performance.It is found that the performance of the JiteScript framework in the class modification is better than the Java library.
The following is an example code that uses the JiteScript framework to add a `setname () method to the Person class:
public class JitescriptExample {
public static void main(String[] args) throws Exception {
// Create ClassWriter
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
// Dynamically modify the existing type of bytecode
new JiteClass(cw)
.defineField("name", String.class, ACC_PRIVATE)
.defineMethod("setName", ACC_PUBLIC, void.class, new Class<?>[]{String.class}, new int[]{0})
.gen()
.beginMethod(ACC_PUBLIC, void.class, "setName", new Class<?>[]{String.class})
.aload(0)
.aload(1)
.putfield("com/example/Person", "name", "Ljava/lang/String;")
.voidreturn()
.endMethod();
// Generate the byte code and load the class
byte[] bytecode = cw.toByteArray();
Class<?> clazz = new ByteArrayClassLoader().defineClass("com.example.Person", bytecode);
// Use the modified class
Object person = clazz.getDeclaredConstructor().newInstance();
Method setNameMethod = clazz.getMethod("setName", String.class);
setNameMethod.invoke(person, "John");
}
}
3. Class method call performance:
We tested the performance of using the JiteScript framework to generate and call the performance of the method and directly call the existing Java class method.It was found that the performance of the method of calling the method after generating a class after generating a class is comparable to the performance of the existing Java class.
The following is a sample code that uses the Person class with the Jitescript framework to generate the Person class and call the method:
public class JitescriptExample {
public static void main(String[] args) throws Exception {
// Create ClassWriter
ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
// Define the class name, interface and parent class
cw.visit(V1_8, ACC_PUBLIC, "com/example/Person", null, "java/lang/Object", null);
// Definition method
MethodVisitor method = cw.visitMethod(ACC_PUBLIC, "sayHello", "()V", null, null);
method.visitCode();
method.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
method.visitLdcInsn("Hello, Jitescript!");
method.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
method.visitInsn(RETURN);
method.visitMaxs(2, 1);
method.visitEnd();
// Generate the byte code and load the class
byte[] bytecode = cw.toByteArray();
Class<?> clazz = new ByteArrayClassLoader().defineClass("com.example.Person", bytecode);
// Use the generating classification method
Object person = clazz.getDeclaredConstructor().newInstance();
Method sayHelloMethod = clazz.getMethod("sayHello");
sayHelloMethod.invoke(person);
}
}
in conclusion:
Through the performance comparison test, we can find that the performance of the JiteScript framework in class generation and modification is better than the commonly used Java library.If you need to generate a class or modify the existing categories, using the JiteScript framework will be a better choice.Of course, when choosing a suitable tool, you should decide according to specific needs and scenes.
It is hoped that the introduction and sample code of this article can help readers better understand the performance comparison of the Jitescript framework and the Java class library.
