Package org.jboss.weld.util.reflection

Class Reflections

java.lang.Object
org.jboss.weld.util.reflection.Reflections
public class Reflections extends Object
Utility class for static reflection-type operations
Author:
Pete Muir, Ales Justin, Marko Luksa

  • Field Details

    • EMPTY_TYPES

      public static final Type[] EMPTY_TYPES

    • EMPTY_ANNOTATIONS

      public static final Annotation[] EMPTY_ANNOTATIONS

    • EMPTY_CLASSES

      public static final Class<?>[] EMPTY_CLASSES

  • Method Details

    • buildTypeMap

      public static Map<Class<?>,Type> buildTypeMap(Set<Type> types)

    • isCacheable

      public static boolean isCacheable(Collection<Annotation> annotations)

    • isCacheable

      public static boolean isCacheable(Annotation[] annotations)

    • cast

      public static <T> T cast(Object obj)

    • getPropertyName

      public static String getPropertyName(Method method)
      Gets the property name from a getter method.

      We extend JavaBean conventions, allowing the getter method to have parameters

      Parameters:
      method - The getter method
      Returns:
      The name of the property. Returns null if method wasn't JavaBean getter-styled

    • isFinal

      public static boolean isFinal(Class<?> clazz)
      Checks if class is final
      Parameters:
      clazz - The class to check
      Returns:
      True if final, false otherwise

    • getNesting

      public static int getNesting(Class<?> clazz)

    • isFinal

      public static boolean isFinal(Member member)
      Checks if member is final
      Parameters:
      member - The member to check
      Returns:
      True if final, false otherwise

    • isPrivate

      public static boolean isPrivate(Member member)
      Checks if member is private
      Parameters:
      member - The member to check
      Returns:
      True if final, false otherwise

    • isTypeOrAnyMethodFinal

      public static boolean isTypeOrAnyMethodFinal(Class<?> type)
      Checks if type or member is final
      Parameters:
      type - Type or member
      Returns:
      True if final, false otherwise

    • getNonPrivateNonStaticFinalMethod

      public static Method getNonPrivateNonStaticFinalMethod(Class<?> type)

    • isPackagePrivate

      public static boolean isPackagePrivate(int mod)

    • isStatic

      public static boolean isStatic(Class<?> type)
      Checks if type is static
      Parameters:
      type - Type to check
      Returns:
      True if static, false otherwise

    • isStatic

      public static boolean isStatic(Member member)
      Checks if member is static
      Parameters:
      member - Member to check
      Returns:
      True if static, false otherwise

    • isTransient

      public static boolean isTransient(Member member)

    • isAbstract

      public static boolean isAbstract(Method method)
      Checks if a method is abstract
      Parameters:
      method - the method
      Returns:
      true if abstract

    • isAbstract

      public static boolean isAbstract(Class<?> clazz)

    • getActualTypeArguments

      public static Type[] getActualTypeArguments(Class<?> clazz)
      Gets the actual type arguments of a class
      Parameters:
      clazz - The class to examine
      Returns:
      The type arguments

    • getActualTypeArguments

      public static Type[] getActualTypeArguments(Type type)
      Gets the actual type arguments of a Type
      Parameters:
      type - The type to examine
      Returns:
      The type arguments

    • isArrayType

      public static boolean isArrayType(Class<?> rawType)
      Checks if raw type is array type
      Parameters:
      rawType - The raw type to check
      Returns:
      True if array, false otherwise

    • isParameterizedType

      public static boolean isParameterizedType(Class<?> type)
      Checks if type is parameterized type
      Parameters:
      type - The type to check
      Returns:
      True if parameterized, false otherwise

    • isParameterizedTypeWithWildcard

      public static boolean isParameterizedTypeWithWildcard(Class<?> type)

    • containsWildcards

      public static boolean containsWildcards(Type[] types)

    • isSerializable

      public static boolean isSerializable(Class<?> clazz)

    • isPrimitive

      public static boolean isPrimitive(Type type)

    • getRawType

      public static <T> Class<T> getRawType(Type type)

    • isClassLoadable

      public static boolean isClassLoadable(String className, org.jboss.weld.resources.spi.ResourceLoader resourceLoader)

    • loadClass

      public static <T> Class<T> loadClass(String className, org.jboss.weld.resources.spi.ResourceLoader resourceLoader)
      Tries to load a class using the specified ResourceLoader. Returns null if the class is not found.
      Parameters:
      className -
      resourceLoader -
      Returns:
      the loaded class or null if the given class cannot be loaded

    • isUnboundedWildcard

      public static boolean isUnboundedWildcard(Type type)

    • isUnboundedTypeVariable

      public static boolean isUnboundedTypeVariable(Type type)

    • isStaticNestedClass

      public static boolean isStaticNestedClass(Class<?> javaClass)
      Parameters:
      javaClass -
      Returns:
      true if the given class is a static nested class, false otherwise

    • isTopLevelOrStaticNestedClass

      public static boolean isTopLevelOrStaticNestedClass(Class<?> javaClass)
      Parameters:
      javaClass -
      Returns:
      true if the given class is a top-level or static nested class, false otherwise

    • invokeAndUnwrap

      public static <T> T invokeAndUnwrap(Object instance, Method method, Object... parameters) throws Throwable
      Invokes the method on a given instance passing in given parameters. If the invocation yields InvocationTargetException, the exception is unwrapped. It is a responsibility of the caller to make sure that the method is accessible to the caller.
      Throws:
      Throwable

    • checkDeclaringClassLoadable

      public static void checkDeclaringClassLoadable(Class<?> c)
      Triggers loading of declaring class (if any) of the given class recursively. If the class cannot be loaded, the underlying LinkageError is propagated.
      Parameters:
      class - the given class
      Throws:
      LinkageError - or its subclass if a declaring class cannot be loaded

    • findDeclaredMethodByName

      public static Method findDeclaredMethodByName(Class<?> clazz, String methodName)
      Searches for a declared method with a given name. If the class declares multiple methods with the given name, there is no guarantee as of which methods is returned. Null is returned if the class does not declare a method with the given name.
      Parameters:
      clazz - the given class
      methodName - the given method name
      Returns:
      method with the given name declared by the given class or null if no such method exists

    • unwrapInvocationTargetException

      public static Exception unwrapInvocationTargetException(InvocationTargetException e) throws Exception
      Unwraps the given InvocationTargetException. Error and Exception are unwrapped right away, Throwable is wrapped within WeldException. This method never returns - it always throws the unwrapped cause instead. The return type matches the throws part of the signature just to simplify usage.
      Parameters:
      the - given exception
      Returns:
      Throws:
      Exception - unwrapped cause of InvocationTargetException

    • getInterfaceClosure

      public static Set<Class<?>> getInterfaceClosure(Class<?> clazz)

    • isDefault

      public static boolean isDefault(Method method)

    • decapitalize

      public static String decapitalize(String name)
      Copy of java.beans.Introspector#decapitalize(name) to reduce java.desktop module dependency. Utility method to take a string and convert it to normal Java variable name capitalization. This normally means converting the first character from upper case to lower case, but in the (unusual) special case when there is more than one character and both the first and second characters are upper case, we leave it alone.

      Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays as "URL".

      Parameters:
      name - The string to be decapitalized.
      Returns:
      The decapitalized version of the string.

    • hasDeclaredField

      public static boolean hasDeclaredField(Class<?> javaClass, String name)
      Checks if given Java class contains a declared field with provided name.
      Parameters:
      javaClass - java class
      name - name of the field
      Returns:
      true if the class declares a field with provided name; false otherwise

    • ensureAccessible

      public static void ensureAccessible(AccessibleObject accessibleObject)
      Set the accessible flag for this accessible object. Uses AccessibleObject.isAccessible() to check accessibility.
      Parameters:
      accessibleObject -

    • ensureAccessible

      public static void ensureAccessible(AccessibleObject accessibleObject, Object instance)
      Set the accessible flag for this accessible object. Uses AccessibleObject.canAccess(Object) to check accessibility.
      Parameters:
      accessibleObject -
      instance - instance of the accessible object you are trying to access

    • getAccessibleCopyOfMember

      public static <T extends AccessibleObject & Member> T getAccessibleCopyOfMember(T member)
      Creates a copy of the given Java member (field, method, constructor) and makes it accessible.
      Type Parameters:
      T -
      Parameters:
      member -
      Returns:

    • lookupField

      public static Field lookupField(Class<?> javaClass, String fieldName) throws NoSuchFieldException
      Looks up a field with given name within the class and any of its superclasses.
      Parameters:
      javaClass -
      fieldName -
      Returns:
      Throws:
      NoSuchMethodException
      NoSuchFieldException

    • lookupMethod

      public static Method lookupMethod(Class<?> javaClass, String methodName, Class<?>[] parameterTypes) throws NoSuchMethodException
      Looks up a method with given name and parameters within the class and any of its superclasses.
      Parameters:
      javaClass -
      methodName -
      parameterTypes -
      Returns:
      Throws:
      NoSuchMethodException

    • wrapException

      public static Method wrapException(Class<?> javaClass, String methodName, Class<?>... parameterTypes)
      Attempts to look up a method based on provided name and parameter types within given class. If the method exists, it is returned; otherwise, the exception throws is wrapped in ReflectionLogger.noSuchMethodWrapper(NoSuchMethodException, String)
      Parameters:
      javaClass - class that should contain the method
      methodName - method name
      parameterTypes - method parameter types
      Returns: