Reflection and method/var handles are two powerful features in Java that allow developers to access and manipulate objects at runtime. However, they differ in the way they access and handle objects.
Let's take a look at an example of how to use reflection to access a method in a class. We'll start with a simple class called "MyClass" that has a private string variable and a getter method for that variable. To create this object, we can use normal instantiation:
MyClass objectInstance = new MyClass("John Doe");
To access the method using reflection, we need to first obtain the class of our object instance using the getClass() method. Then, we can use the getDeclaredMethod() method to find the method we want to access, in this case, "getName". Finally, we need to invoke the method using the invoke() method and pass in our object instance. Here is the code for this process:
Class<?> clazz = objectInstance.getClass();
Method method = clazz.getDeclaredMethod("getName");
String value = (String) method.invoke(objectInstance);
System.out.println(value); // prints "John Doe"
On the other hand, method handles, found in the MethodHandles class, provide a safer and more optimized way to access methods. This is because they were designed specifically for this purpose and are enhanced for JVM optimization.
Using method handles to access a method is similar to using reflection. We start by obtaining the class of our object instance. Then, we use the findVirtual() method on MethodHandles to look up the method we want to access. Next, we call the method using the invoke() method and pass in our object instance. Here is the code for this process:
Class<?> clazz = objectInstance.getClass();
MethodHandle handle = MethodHandles.lookup().findVirtual(clazz, "getName", methodType(String.class));
String value = (String) handle.invoke(objectInstance);
System.out.println(value); // Prints “John Doe”
However, there are limitations to what method handles can do. They cannot handle tasks such as instantiating classes, which is possible with reflection.
To showcase the power of method handles, let's take a look at how they can be used to directly access a private field in a class. Let's say our "MyClass" class has a private string variable called "name". We could use reflection to access it, but using method handles is a safer alternative.
To directly access a private field using reflection, we first need to obtain the class of our object instance. Then, we use the getDeclaredField() method to find the field we want to access, in this case, "name". However, since this field is private, we need to use the setAccessible() method to set its accessibility to true. Finally, we can use the get() method to retrieve the value of the field. Here is the code for this process:
Class<?> clazz = objectInstance.getClass();
Field field = clazz.getDeclaredField("name");
field.setAccessible(true);
String value = (String) field.get(objectInstance);
System.out.println(value); // prints “John Doe”
Using method handles, the process is similar. We start by obtaining the class of our object instance, and then we use the privateLookupIn() method on MethodHandles to respect the access modifiers of the field (since it is private). Next, we use the findVarHandle() method to find the field we want to access. Finally, we can use the get() method to retrieve its value. Here is the code for this process:
Class<?> clazz = objectInstance.getClass();
VarHandle handle = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()).findVarHandle(clazz, "name", String.class);
String value = (String) handle.get(objectInstance);
System.out.println(value); // prints “John Doe”
It is recommended to statically instantiate the handle for performance reasons, but this requires knowing the name of the class. If you do not know the name of the class, it is not possible to use this approach.
One limitation of method handles is that they do not provide a way to handle checked exceptions. Various operations on method handles and var handles throw checked exceptions that must be caught and declared in production code.
In conclusion, method and variable handles provide a focused range of capabilities in the JDK for finding class metadata and accessing methods and fields outside of normal Java restrictions. While they do not cover all the capabilities of reflection, they offer safer and more optimized alternatives for these tasks.
Experience the best way to study for Java Certification with MyExamCloud's Study Plans and enjoy complimentary practice tests.
Top comments (0)