Class ReflectUtil

java.lang.Object
manifold.util.ReflectUtil
public class ReflectUtil extends Object
A Java reflection utility. Use it to efficiently access classes by name, get/set field values, invoke methods, and use constructors. Notable features include:
  • Intuitive, fluent API
  • Call any method: private, filtered, inaccessible, etc.
  • Get and set the value of a final field
  • Access fields and methods of a class belonging to an inaccessible module
  • Call a super method
  • Call a default interface method esp. for a proxy
  • Call a method structurally with automatic best method matching
  • Fields, methods, and constructors are cached upon use to improve performance
  • Works with all versions of Java beginning with Java 8

(Use @Jailbreak to avoid writing reflection code. See Type-safe Reflection.)

  • Constructor Details

    • ReflectUtil

      public ReflectUtil()

  • Method Details

    • type

      public static Class<?> type(String fqn)
      Searches the class loader of this class for the specified name, if not found searches the current thread's context class loader.
      Parameters:
      fqn - The qualified name of the type e.g., "java.lang.String" or "java.lang.String[]"
      Returns:
      The Class corresponding with fqn or null if not found

    • type

      public static Class<?> type(String fqn, boolean useCallChain)

    • type

      public static Class<?> type(String fqn, ClassLoader cl)
      Searches cl for the specified class fqn.
      Parameters:
      fqn - The qualified name of the type e.g., "java.lang.String"
      cl - The class loader to search
      Returns:
      The Class corresponding with fqn or null if not found

    • type

      public static Class<?> type(String fqn, ClassLoader cl, boolean useCallChain)

    • method

      public static ReflectUtil.LiveMethodRef method(Object receiver, String name, Class... params)
      Get a ReflectUtil.LiveMethodRef to the specified method. Typical use: 

       method(str, "substring", int.class).invoke(2)
      Parameters:
      receiver - The object to make the call on
      name - The name of the method to call or a '|' separated list of names, where the first found is used
      params - The types of the method's parameters
      Returns:
      A reference to the specified method, throws RuntimeException if the method is not found. Use ReflectUtil.WithNull to avoid the RuntimeException.

    • method

      public static ReflectUtil.MethodRef method(String fqn, String name, Class... params)
      Get a ReflectUtil.MethodRef to the specified method. Typical use: 

       method("java.time.LocalTime", "of", int.class, int.class).invokeStatic(5, 30)
      Parameters:
      fqn - The qualified name of the class containing the method
      name - The name of the method or a '|' separated list of names, where the first found is used
      params - The types of the method's parameters
      Returns:
      A reference to the specified method or null if not found

    • method

      public static ReflectUtil.MethodRef method(Class<?> cls, String name, Class... params)
      Get a ReflectUtil.MethodRef to the specified method. Typical use: 

       method(LocalTime.class, "of", int.class, int.class).invokeStatic(5, 30)
      Parameters:
      cls - The class containing the method
      name - The name of the method or a '|' separated list of names, where the first found is used
      params - The types of the method's parameters
      Returns:
      A reference to the specified method or null if not found

    • methodFromName

      public static ReflectUtil.MethodRef methodFromName(Class<?> cls, String name)
      Get a ReflectUtil.MethodRef to the specified name without regard to parameter types. If more than one method has the name, the first one encountered is used, in no particular order. This method should be used only when the named method is not overloaded. Typical use: 

       methodByName(LocalTime.class, "isAfter").invoke(source, time)
      Parameters:
      cls - The class containing the method
      name - The name of the method or a '|' separated list of names, where the first found is used
      Returns:
      A reference to the specified method or null if not found

    • lambdaMethod

      public static ReflectUtil.MethodRef lambdaMethod(Class<?> lambdaClass)
      Get a ReflectUtil.MethodRef corresponding with the functional interface implemented by lambdaClass. 

       lambdaMethod(function.getClass()).invoke(function, args)
      Returns:
      A reference to the specified method or null if not found

    • invokeDefault

      public static Object invokeDefault(Object receiver, Class<?> iface, String name, Class<?>[] params, Object... args)
      This method behaves like the one below it, except this method ensures the iface default method is called even if the receiver overrides it. Essentially, this method is like calling Iface.super.method() from the receiver's perspective.

    • invokeDefault

      public static Object invokeDefault(Object receiver, Method method, Object... args)
      Invoke a default interface method.

      This is useful, for example, for a proxy implementation where there is no explicit implementation of the interface on which to invoke the default method.

      Parameters:
      receiver - The receiver of the call (the proxy instance in the case of a proxy impl).
      method - The default interface method to invoke on receiver.
      args - The arguments to method.
      Returns:
      The return value of method or null if the method has a void return type.

    • field

      public static ReflectUtil.LiveFieldRef field(Object receiver, String name)
      Get a ReflectUtil.LiveFieldRef to the specified field. Typical use: 

       String name = field(foo, "name").get();
      Parameters:
      receiver - The object having the field
      name - The name of the field or a '|' separated list of names, where the first found is used
      Returns:
      A reference to the specified field, throws RuntimeException if the field is not found. Use ReflectUtil.WithNull to avoid the RuntimeException.

    • field

      public static ReflectUtil.FieldRef field(String fqn, String name)
      Get a ReflectUtil.FieldRef to the specified field. Typical use: 

       field("java.time.LocalTime", "hour").get(time);
      Parameters:
      fqn - The qualified name of the class having the field
      name - The name of the field or a '|' separated list of names, where the first found is used
      Returns:
      A reference to the specified field or null if not found

    • field

      public static ReflectUtil.FieldRef field(Class<?> cls, String name)
      Get a ReflectUtil.FieldRef to the specified field. Typical use: 

       field(LocalTime.class, "hour").get(time);
      Parameters:
      cls - The class having the field
      name - The name of the field or a '|' separated list of names, where the first found is used
      Returns:
      A reference to the specified field or null if not found

    • fields

      public static List<ReflectUtil.LiveFieldRef> fields(Object receiver)
      Visit declared fields of the receiver class. Stop if fun return false.

    • fields

      public static List<ReflectUtil.LiveFieldRef> fields(Object receiver, Predicate<ReflectUtil.LiveFieldRef> filter)

    • constructor

      public static ReflectUtil.ConstructorRef constructor(String fqn, Class<?>... params)
      Get a ReflectUtil.ConstructorRef to the specified constructor. Typical use: 

       constructor("java.util.ArrayList", int.class).newInstance(32)
      Parameters:
      fqn - The qualified name of the class to construct
      params - A list of parameter types for the constructor
      Returns:
      A reference to the constructor or null if not found

    • constructor

      public static ReflectUtil.ConstructorRef constructor(Class<?> cls, Class<?>... params)
      Get a ReflectUtil.ConstructorRef to the specified constructor. Typical use: 

       constructor(ArrayList.class, int.class).newInstance(32)
      Parameters:
      cls - The class to construct
      params - A list of parameter types for the constructor
      Returns:
      A reference to the constructor or null if not found

    • setAccessible

      public static void setAccessible(Field f)

    • setAccessible

      public static void setAccessible(Method m)

    • setAccessible

      public static void setAccessible(Constructor c)

    • setAccessible

      public static void setAccessible(Member m)

    • preloadClassIntoParentLoader

      public static void preloadClassIntoParentLoader(String fqn, URI content, ClassLoader wouldBeLoader, ClassLoader parentLoader)
      Force class with name fqn to be loaded by parentLoader. Facilitates the case where a class must be declared in a package defined in a parent class loader in order to subclass and use package-local features defined there.

      Note fqn's natural class loader must have the parentLoader in its chain of parent loaders. Also be certain fqn is not already loaded by its natural loader, otherwise LinkageErrors will result.

      Parameters:
      fqn - The qualified name of the class to load
      content - The location of the class resource. With Java 8 this can be wouldBeLoader.getResource(className). But with Java 9 and later the JPMS strictly prohibits a package from existing in two loaders, therefore the class file must be placed in a different package, perhaps prefixed with a suitably named root package, otherwise the VM will throw a LayerInstantiationException when your application loads, before any of your code executes.
      wouldBeLoader - The class loader that would naturally load fqn, must have parentLoader in its parent loader chain
      parentLoader - The class loader to load the class in, must be in the parent chain of wouldBeLoader

    • structuralMethod

      public static ReflectUtil.MethodRef structuralMethod(Class target, Class structIface, String name, Class... params)

    • structuralMethod

      public static ReflectUtil.LiveMethodRef structuralMethod(Object receiver, Class structIface, String name, Class... params)

    • structuralCall

      public static Object structuralCall(Method structMethod, Object receiver, Object... args)

    • structuralCallByProxy

      public static Object structuralCallByProxy(Method structMethod, Object proxy, Object receiver, Object... args)

    • arePrimitiveTypesAssignable

      public static boolean arePrimitiveTypesAssignable(Class toType, Class fromType)

    • findBestMethod

      public static Method findBestMethod(Method structMethod, Class receiverClass)

    • setContextClassLoader

      public static void setContextClassLoader(ClassLoader cl)
      Uses reflection to set Thread#contextClassLoader primarily to sidestep a bug introduced in the JDK where if a SecurityManager is set, ForkJoinPool uses InnocuousForkJoinWorkerThread which overrides setContextClassLoader() to prevent it from being used by throwing an exception. It is best to use reflection to set the contextClassLoader directly.

      Note, the JDK issue happens when launching the IntelliJ runIde task for plugin dev.