The technical principles and performance optimization research in the ObjenesIS framework in the Java library
Objeneis is an open source Java library that is used to instantiate an object of a class without calling its constructor.It directly creates an object instance by bypassing the calls of the constructor, thereby improving the instantiated performance of the object.
ObjenesIS's technical principles are very simple. It uses Java's reflection mechanism to bypass the constructor of the class to directly create an object instance.It provides a variety of implementation methods, including byte code generating libraries, byte code injection and using UNSAFE classes.Among them, the bytecode generating library is one of the main implementation methods of ObjinSis.
Below is a sample code using ObjinSis:
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;
public class ObjenesisExample {
public static void main(String[] args) {
// Create ObjinSis instance
Objenesis objenesis = new ObjenesisStd();
// Use Objeneisis to create a Person object instance
Person person = objenesis.newInstance(Person.class);
// Output the information of the Person object
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
// Example Person
class Person {
private String name;
private int age;
public Person() {
this.name = "John";
this.age = 25;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
In the above sample code, by using Objenesis's `newInstance () method, we can directly create a Person object instance without calling its constructor.In this way, we can obtain an initialized object without calling the constructor.
Although Objnesis provides more efficient object instance, its performance is not absolute, because the reflection mechanism itself will bring certain performance expenses.Therefore, in the scenario with high performance requirements, it is recommended to optimize performance to reduce performance losses.
In order to optimize the performance of Objeneis, the following strategies can be adopted:
1. Caches OBJNESIS instance: You can create a cache of an ObjenesIS instance. You can obtain an instance directly from the cache where you need to create an object repeatedly to avoid the overhead of repeatedly creating instances.
2. Avoid unnecessary reflex: minimize the reflection mechanism as much as possible, especially in the frequent calls.The creation process of some objects can be advanced to avoid reflection on the critical path.
3. Use more efficient reflection tools: ObjinSis is a commonly used reflection tool, but it is not the best performance.You can try other more efficient reflection tools, such as Javassist or byte Buddy to improve performance.
In summary, Objeneis is a very useful Java library that can bypass the constructor to directly create an object instance.Through reasonable use and performance optimization, it can improve the instantiated performance of the object and bring obvious performance advantages in some scenarios.
