Java - Hidden Classes

Java 15 has introduced hidden classes which cannot be used directly by other classes bytecode. These hidden classes are intended to be used by frameworks that generate classes at runtime and use them using reflection.

A hidden class is defined as a member of the Based Access Control Context and it can be unloaded irrespective of other classes.

This proposal, JEP 371, aims at the improvement of all languages on JVM by providing a standard API to define hidden classes that are not discoverable and have a limited lifecycle. JDK frameworks or external frameworks can generate classes dynamically which can generate hidden classes.

JVM languages rely heavily on dynamic class generation for flexibility and efficiency.

Goals

Following is the list of targetted goals of this enhancement:

• Frameworks should be able to define classes as non-discoverable implementation details of the framework, These classes can neither be linked to other classes nor discoverable using reflection.
• Extend Access Control Nest with non-discoverable classes.
• Aggressive unloading of hidden classes will help frameworks to define as many hidden classes as required without degrading the performance.
• Deprecate the non-standard API, misc.Unsafe::defineAnonymousClass, to be removed in future releases.

Creating a Hidden Class

In order to create a hidden class, we must create a Lookup instance as shown below:

MethodHandles.Lookup lookup = MethodHandles.lookup();

Once lookup instance is available, we can use defineHiddenClass() method to create hidden class using bytearray of hidden class.

 Class<?> hiddenClass = lookup.defineHiddenClass(getByteArray(), true, ClassOption.NESTMATE).lookupClass();

Bytearray of hidden class can be retrieved using classpath of the hidden class.

public static byte[] getByteArray() throws IOException {
   InputStream stream = Util.class.getClassLoader().getResourceAsStream("com/tutorialspoint/Util.class");
   byte[] bytes = stream.readAllBytes();
   return bytes;
}

Once hiddenClass class is loaded, we can create its instance using getConstructor() method.

 Object hiddenClassObj = hiddenClass.getConstructor().newInstance();

Using hidden class instance, we can get the method and then execute it as shown below:

Method method = hiddenClassObj.getClass().getDeclaredMethod("square", Integer.class);
// call the method and get result
Object result = method.invoke(hiddenClassObj, 3);

As hidden class is hidden and cannot be instantiated using reflection, its hidden property is true and canonical name is null.

Example to Create and Use a Hidden Class

Following example shows the creation and use of a hidden class. First we've created a public class Util as shown below:

package com.tutorialspoint;

public class Util {
   public Integer square(Integer n) {
      return n * n;
   }
}

Now we've created this class as a hidden class and accesed its method to get the square of a number.

package com.tutorialspoint;

import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup.ClassOption;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Tester {
   public static void main(String args[]) throws IllegalAccessException, IOException, InstantiationException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
      // create the lookup object	   
      MethodHandles.Lookup lookup = MethodHandles.lookup();
      // define the hidden class using the byte array of Util class
      // Using NESTMATE option so that hidden class has access to 
      // private members of classes in same nest
      Class<?> hiddenClass = lookup.defineHiddenClass(getByteArray(),
         true, ClassOption.NESTMATE).lookupClass();

      // get the hidden class object
      Object hiddenClassObj = hiddenClass.getConstructor().newInstance();

      // get the hidden class method
      Method method = hiddenClassObj.getClass().getDeclaredMethod("square", Integer.class);

      // call the method and get result
      Object result = method.invoke(hiddenClassObj, 3);

      // print the result
      System.out.println(result);

      // as hidden class is not visible to jvm, it will print hidden
      System.out.println(hiddenClass.isHidden());

      // canonical name is null thus this class cannot be instantiated using reflection 
      System.out.println(hiddenClass.getCanonicalName());

   }
   public static byte[] getByteArray() throws IOException {
      InputStream stream = Util.class.getClassLoader().getResourceAsStream("com/tutorialspoint/Util.class");
      byte[] bytes = stream.readAllBytes();
      return bytes;
   }
}

Let us compile and run the above program, this will produce the following result −

9
true
null