Package org.keycloak.common.util.reflections

Class Reflections

  • public class Reflections
extends Object
    Utility class for working with JDK Reflection and also CDI's {link Annotated} metadata.

    • Field Detail

      • EMPTY_ANNOTATION_ARRAY

        public static final Annotation[] EMPTY_ANNOTATION_ARRAY
        An empty array of type Annotation, useful converting lists to arrays.

      • EMPTY_OBJECT_ARRAY

        public static final Object[] EMPTY_OBJECT_ARRAY
        An empty array of type Object, useful for converting lists to arrays.

      • EMPTY_TYPES

        public static final Type[] EMPTY_TYPES

      • EMPTY_CLASSES

        public static final Class<?>[] EMPTY_CLASSES

    • Method Detail

      • cast

        public static <T> T cast​(Object obj)

        Perform a runtime cast. Similar to Class.cast(Object), but useful when you do not have a Class object for type you wish to cast to.

        Class.cast(Object) should be used if possible

        Type Parameters:
        T - the type to cast to
        Parameters:
        obj - the object to perform the cast on
        Returns:
        the casted object
        Throws:
        ClassCastException - if the type T is not a subtype of the object
        See Also:
        Class.cast(Object)

      • getAllDeclaredFields

        public static Set<Field> getAllDeclaredFields​(Class<?> clazz)
        Get all the declared fields on the class hierarchy. This will return overridden fields.
        Parameters:
        clazz - The class to search
        Returns:
        the set of all declared fields or an empty set if there are none

      • findDeclaredField

        public static Field findDeclaredField​(Class<?> clazz,
                                      String name)
        Search the class hierarchy for a field with the given name. Will return the nearest match, starting with the class specified and searching up the hierarchy.
        Parameters:
        clazz - The class to search
        name - The name of the field to search for
        Returns:
        The field found, or null if no field is found

      • getAnnotationsWithMetaAnnotation

        public static Set<Annotation> getAnnotationsWithMetaAnnotation​(Set<Annotation> annotations,
                                                               Class<? extends Annotation> metaAnnotationType)
        Search for annotations with the specified meta annotation type
        Parameters:
        annotations - The annotation set to search
        metaAnnotationType - The type of the meta annotation to search for
        Returns:
        The set of annotations with the specified meta annotation, or an empty set if none are found

      • methodExists

        public static boolean methodExists​(Class<?> clazz,
                                   String name)
        Determine if a method exists in a specified class hierarchy
        Parameters:
        clazz - The class to search
        name - The name of the method
        Returns:
        true if a method is found, otherwise false

      • getAllDeclaredMethods

        public static Set<Method> getAllDeclaredMethods​(Class<?> clazz)
        Get all the declared methods on the class hierarchy. This will return overridden methods.
        Parameters:
        clazz - The class to search
        Returns:
        the set of all declared methods or an empty set if there are none

      • findDeclaredMethod

        public static Method findDeclaredMethod​(Class<?> clazz,
                                        String name,
                                        Class<?>... args)
        Search the class hierarchy for a method with the given name and arguments. Will return the nearest match, starting with the class specified and searching up the hierarchy.
        Parameters:
        clazz - The class to search
        name - The name of the method to search for
        args - The arguments of the method to search for
        Returns:
        The method found, or null if no method is found

      • findDeclaredConstructor

        public static Constructor<?> findDeclaredConstructor​(Class<?> clazz,
                                                     Class<?>... args)
        Search the class hierarchy for a constructor with the given arguments. Will return the nearest match, starting with the class specified and searching up the hierarchy.
        Parameters:
        clazz - The class to search
        args - The arguments of the constructor to search for
        Returns:
        The constructor found, or null if no constructor is found

      • getAllDeclaredConstructors

        public static Set<Constructor<?>> getAllDeclaredConstructors​(Class<?> clazz)
        Get all the declared constructors on the class hierarchy. This will return overridden constructors.
        Parameters:
        clazz - The class to search
        Returns:
        the set of all declared constructors or an empty set if there are none

      • getMemberType

        public static Class<?> getMemberType​(Member member)
        Get the type of the member
        Parameters:
        member - The member
        Returns:
        The type of the member
        Throws:
        UnsupportedOperationException - if the member is not a field, method, or constructor

      • classForName

        public static <T> Class<T> classForName​(String name,
                                        ClassLoader... loaders)
                                 throws ClassNotFoundException

        Loads and initializes a class for the given name.

        If the Thread Context Class Loader is available, it will be used, otherwise the classloader used to load Reflections will be used

        It is also possible to specify additional classloaders to attempt to load the class with. If the first attempt fails, then these additional loaders are tried in order.

        Parameters:
        name - the name of the class to load
        loaders - additional classloaders to use to attempt to load the class
        Returns:
        the class object
        Throws:
        ClassNotFoundException - if the class cannot be found

      • invokeMethod

        public static <T> T invokeMethod​(boolean setAccessible,
                                 Method method,
                                 Class<T> expectedReturnType,
                                 Object instance,
                                 Object... args)

        Invoke the method on the instance, with any arguments specified, casting the result of invoking the method to the expected return type.

        This method wraps Method.invoke(Object, Object...), converting the checked exceptions that Method.invoke(Object, Object...) specifies to runtime exceptions.

        If instructed, this method attempts to set the accessible flag of the method in a {link PrivilegedAction} before invoking the method.

        Parameters:
        setAccessible - flag indicating whether method should first be set as accessible
        method - the method to invoke
        instance - the instance to invoke the method
        args - the arguments to the method
        Returns:
        the result of invoking the method, or null if the method's return type is void
        Throws:
        RuntimeException - if this Method object enforces Java language access control and the underlying method is inaccessible or if the underlying method throws an exception or if the initialization provoked by this method fails.
        IllegalArgumentException - if the method is an instance method and the specified instance argument is not an instance of the class or interface declaring the underlying method (or of a subclass or implementor thereof); if the number of actual and formal parameters differ; if an unwrapping conversion for primitive arguments fails; or if, after possible unwrapping, a parameter value cannot be converted to the corresponding formal parameter type by a method invocation conversion.
        NullPointerException - if the specified instance is null and the method is an instance method.
        ClassCastException - if the result of invoking the method cannot be cast to the expectedReturnType
        ExceptionInInitializerError - if the initialization provoked by this method fails.
        See Also:
        Method.invoke(Object, Object...)

      • setAccessible

        public static <A extends AccessibleObject> A setAccessible​(A member)
        Set the accessibility flag on the AccessibleObject as described in AccessibleObject.setAccessible(boolean) within the context of a {link PrivilegedAction}.
        Type Parameters:
        A - member the accessible object type
        Parameters:
        member - the accessible object
        Returns:
        the accessible object after the accessible flag has been altered

      • unsetAccessible

        public static <A extends AccessibleObject> A unsetAccessible​(A member)
        Set the accessibility flag on the AccessibleObject to false as described in AccessibleObject.setAccessible(boolean) within the context of a {link PrivilegedAction}.
        Type Parameters:
        A - member the accessible object type
        Parameters:
        member - the accessible object
        Returns:
        the accessible object after the accessible flag has been altered

      • getFieldValue

        public static Object getFieldValue​(Field field,
                                   Object instance)

      • getFieldValue

        public static <T> T getFieldValue​(Field field,
                                  Object instance,
                                  Class<T> expectedType)

        Get the value of the field, on the specified instance, casting the value of the field to the expected type.

        This method wraps Field.get(Object), converting the checked exceptions that Field.get(Object) specifies to runtime exceptions.

        Type Parameters:
        T - the type of the field's value
        Parameters:
        field - the field to operate on
        instance - the instance from which to retrieve the value
        expectedType - the expected type of the field's value
        Returns:
        the value of the field
        Throws:
        RuntimeException - if the underlying field is inaccessible.
        IllegalArgumentException - if the specified instance is not an instance of the class or interface declaring the underlying field (or a subclass or implementor thereof).
        NullPointerException - if the specified instance is null and the field is an instance field.
        ExceptionInInitializerError - if the initialization provoked by this method fails.

      • getRawType

        public static <T> Class<T> getRawType​(Type type)
        Extract the raw type, given a type.
        Type Parameters:
        T - the type
        Parameters:
        type - the type to extract the raw type from
        Returns:
        the raw type, or null if the raw type cannot be determined.

      • isSerializable

        public static boolean isSerializable​(Class<?> clazz)
        Check if a class is serializable.
        Parameters:
        clazz - The class to check
        Returns:
        true if the class implements serializable or is a primitive

      • isCacheable

        public static boolean isCacheable​(Set<Annotation> annotations)

      • isCacheable

        public static boolean isCacheable​(Annotation[] annotations)

      • 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

      • getNonPrivateFinalMethodOrType

        public static Object getNonPrivateFinalMethodOrType​(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 -
        Returns:

      • 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

      • isParamerterizedTypeWithWildcard

        public static boolean isParamerterizedTypeWithWildcard​(Class<?> type)

      • containsWildcards

        public static boolean containsWildcards​(Type[] types)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Class<?> rawType1,
                                       Type[] actualTypeArguments1,
                                       Class<?> rawType2,
                                       Type[] actualTypeArguments2)
        Check the assignability of one type to another, taking into account the actual type arguements
        Parameters:
        rawType1 - the raw type of the class to check
        actualTypeArguments1 - the actual type arguements to check, or an empty array if not a parameterized type
        rawType2 - the raw type of the class to check
        actualTypeArguments2 - the actual type arguements to check, or an empty array if not a parameterized type
        Returns:

      • matches

        public static boolean matches​(Class<?> rawType1,
                              Type[] actualTypeArguments1,
                              Class<?> rawType2,
                              Type[] actualTypeArguments2)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Type[] actualTypeArguments1,
                                       Type[] actualTypeArguments2)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Type type1,
                                       Set<? extends Type> types2)

      • matches

        public static boolean matches​(Type type1,
                              Set<? extends Type> types2)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Type type1,
                                       Type[] types2)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Type type1,
                                       Type type2)

      • matches

        public static boolean matches​(Type type1,
                              Type type2)

      • isTypeBounded

        public static boolean isTypeBounded​(Type type,
                                    Type[] lowerBounds,
                                    Type[] upperBounds)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Class<?> rawType1,
                                       Type[] actualTypeArguments1,
                                       Type type2)

      • matches

        public static boolean matches​(Class<?> rawType1,
                              Type[] actualTypeArguments1,
                              Type type2)

      • isAssignableFrom

        public static boolean isAssignableFrom​(Set<Type> types1,
                                       Set<Type> types2)
        Check the assiginability of a set of flattened types. This algorithm will check whether any of the types1 matches a type in types2
        Parameters:
        types1 -
        types2 -
        Returns:

      • matches

        public static boolean matches​(Set<Type> types1,
                              Set<Type> types2)
        Check whether whether any of the types1 matches a type in types2
        Parameters:
        types1 -
        types2 -
        Returns:

      • isAssignableFrom

        public static boolean isAssignableFrom​(Set<Type> types1,
                                       Type type2)
        Check the assignability of a set of flattened types. This algorithm will check whether any of the types1 matches a type in types2
        Parameters:
        types1 -
        type2 -
        Returns:

      • isAssignableFrom

        public static boolean isAssignableFrom​(Type[] types1,
                                       Type type2)

      • isPrimitive

        public static boolean isPrimitive​(Type type)

      • resolveListType

        public static Class<?> resolveListType​(Field field,
                                       Object instance)
                                throws IllegalAccessException

        Resolves the type of items for a Field declared as a List.

        This method will first try to check the parametrized type of the field type. If none is defined, it will try to infer the type of items by looking at the value of the field for the given instance.

        Make sure the field is accessible before invoking this method.

        Parameters:
        field - the field declared as List
        instance - the instance that should be used to obtain infer the type in case no parametrized type is found in the field.
        Returns:
        if the field is not a List, it returns null. Otherwise the type of items of the list. If the type for items can not be inferred, the Object type is returned.
        Throws:
        IllegalAccessException - in case it fails to obtain the value of the field from the instance