org.keycloak.common.util.reflections.Reflections クラス

org.keycloak.common.util.reflections.Reflections 連携図

静的公開メンバ関数
static< T > T	cast (Object obj)
static Set< Field >	getAllDeclaredFields (Class<?> clazz)
static Field	findDeclaredField (Class<?> clazz, String name)
static Set< Annotation >	getAnnotationsWithMetaAnnotation (Set< Annotation > annotations, Class<? extends Annotation > metaAnnotationType)
static boolean	methodExists (Class<?> clazz, String name)
static Set< Method >	getAllDeclaredMethods (Class<?> clazz)
static Method	findDeclaredMethod (Class<?> clazz, String name, Class<?>... args)
static Constructor<?>	findDeclaredConstructor (Class<?> clazz, Class<?>... args)
static Set< Constructor<?> >	getAllDeclaredConstructors (Class<?> clazz)
static Class<?>	getMemberType (Member member)
static< T > Class< T >	classForName (String name, ClassLoader... loaders) throws ClassNotFoundException
static Object	invokeMethod (Method method, Object instance, Object... args)
static Object	invokeMethod (boolean setAccessible, Method method, Object instance, Object... args)
static< T > T	invokeMethod (Method method, Class< T > expectedReturnType, Object instance, Object... args)
static< T > T	invokeMethod (boolean setAccessible, Method method, Class< T > expectedReturnType, Object instance, Object... args)
static< A extends AccessibleObject > A	setAccessible (A member)
static Object	getFieldValue (Field field, Object instance)
static< T > T	getFieldValue (Field field, Object instance, Class< T > expectedType)
static< T > Class< T >	getRawType (Type type)
static boolean	isSerializable (Class<?> clazz)
static Map< Class<?>, Type >	buildTypeMap (Set< Type > types)
static boolean	isCacheable (Set< Annotation > annotations)
static boolean	isCacheable (Annotation[] annotations)
static String	getPropertyName (Method method)
static boolean	isFinal (Class<?> clazz)
static int	getNesting (Class<?> clazz)
static boolean	isFinal (Member member)
static boolean	isPrivate (Member member)
static boolean	isTypeOrAnyMethodFinal (Class<?> type)
static Object	getNonPrivateFinalMethodOrType (Class<?> type)
static boolean	isPackagePrivate (int mod)
static boolean	isStatic (Class<?> type)
static boolean	isStatic (Member member)
static boolean	isTransient (Member member)
static boolean	isAbstract (Method method)
static boolean	isArrayType (Class<?> rawType)
static boolean	isParameterizedType (Class<?> type)
static boolean	isParamerterizedTypeWithWildcard (Class<?> type)
static boolean	containsWildcards (Type[] types)
static boolean	isAssignableFrom (Class<?> rawType1, Type[] actualTypeArguments1, Class<?> rawType2, Type[] actualTypeArguments2)
static boolean	matches (Class<?> rawType1, Type[] actualTypeArguments1, Class<?> rawType2, Type[] actualTypeArguments2)
static boolean	isAssignableFrom (Type[] actualTypeArguments1, Type[] actualTypeArguments2)
static boolean	isAssignableFrom (Type type1, Set<? extends Type > types2)
static boolean	matches (Type type1, Set<? extends Type > types2)
static boolean	isAssignableFrom (Type type1, Type[] types2)
static boolean	isAssignableFrom (Type type1, Type type2)
static boolean	matches (Type type1, Type type2)
static boolean	isTypeBounded (Type type, Type[] lowerBounds, Type[] upperBounds)
static boolean	isAssignableFrom (Class<?> rawType1, Type[] actualTypeArguments1, Type type2)
static boolean	matches (Class<?> rawType1, Type[] actualTypeArguments1, Type type2)
static boolean	isAssignableFrom (Set< Type > types1, Set< Type > types2)
static boolean	matches (Set< Type > types1, Set< Type > types2)
static boolean	isAssignableFrom (Set< Type > types1, Type type2)
static boolean	isAssignableFrom (Type[] types1, Type type2)
static boolean	isPrimitive (Type type)
static< T > T	newInstance (final Class< T > fromClass) throws ClassNotFoundException, IllegalAccessException, InstantiationException
static< T > T	newInstance (final Class<?> type, final String fullQualifiedName) throws ClassNotFoundException, IllegalAccessException, InstantiationException

静的公開変数類
static final Annotation []	EMPTY_ANNOTATION_ARRAY = new Annotation[0]
static final Object []	EMPTY_OBJECT_ARRAY = new Object[0]
static final Type []	EMPTY_TYPES = {}
static final Class<?> []	EMPTY_CLASSES = new Class<?>[0]

非公開メンバ関数
	Reflections ()

静的非公開メンバ関数
static String	buildInvokeMethodErrorMessage (Method method, Object obj, Object... args)
static String	buildSetFieldValueErrorMessage (Field field, Object obj, Object value)
static String	buildGetFieldValueErrorMessage (Field field, Object obj)

詳解

Utility class for working with JDK Reflection and also CDI's {link Annotated} metadata.

構築子と解体子

Reflections()

org.keycloak.common.util.reflections.Reflections.Reflections ( )

inlineprivate

                          {
    }

関数詳解

buildGetFieldValueErrorMessage()

static String org.keycloak.common.util.reflections.Reflections.buildGetFieldValueErrorMessage ( Field  field, Object  obj  )

inlinestaticprivate

                                                                                  {
        return String.format("Exception reading [%s] field from object [%s].", field.getName(), obj);
    }

buildInvokeMethodErrorMessage()

static String org.keycloak.common.util.reflections.Reflections.buildInvokeMethodErrorMessage ( Method  method, Object  obj, Object...  args  )

inlinestaticprivate

                                                                                                   {
        StringBuilder message = new StringBuilder(
                String.format("Exception invoking method [%s] on object [%s], using arguments [",
                        method.getName(), obj));
        if (args != null) {
            for (int i = 0; i < args.length; i++) {
                message.append((i > 0 ? "," : "") + args[i]);
            }
        }
        message.append("]");
        return message.toString();
    }

buildSetFieldValueErrorMessage()

static String org.keycloak.common.util.reflections.Reflections.buildSetFieldValueErrorMessage ( Field  field, Object  obj, Object  value  )

inlinestaticprivate

                                                                                                {
        return String.format("Exception setting [%s] field on object [%s] to value [%s]", field.getName(), obj, value);
    }

buildTypeMap()

static Map<Class<?>, Type> org.keycloak.common.util.reflections.Reflections.buildTypeMap ( Set< Type >  types )

inlinestatic

                                                                    {
        Map<Class<?>, Type> map = new HashMap<Class<?>, Type>();
        for (Type type : types) {
            if (type instanceof Class<?>) {
                map.put((Class<?>) type, type);
            } else if (type instanceof ParameterizedType) {
                if (((ParameterizedType) type).getRawType() instanceof Class<?>) {
                    map.put((Class<?>) ((ParameterizedType) type).getRawType(), type);
                }
            } else if (type instanceof TypeVariable<?>) {

            }
        }
        return map;
    }

cast()

static <T> T org.keycloak.common.util.reflections.Reflections.cast ( Object  obj )

inlinestatic

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

引数

<T>	the type to cast to
obj	the object to perform the cast on

戻り値

the casted object

例外

ClassCastException

if the type T is not a subtype of the object

参照

Class::cast(Object)

                                         {
        return (T) obj;
    }

classForName()

static <T> Class<T> org.keycloak.common.util.reflections.Reflections.classForName ( String  name, ClassLoader...  loaders  ) throws ClassNotFoundException

inlinestatic

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.

引数

name	the name of the class to load
loaders	additional classloaders to use to attempt to load the class

戻り値

the class object

例外

ClassNotFoundException

if the class cannot be found

                                                                                                               {
        try {
            if (Thread.currentThread().getContextClassLoader() != null) {
                return (Class<T>) Class.forName(name, true, Thread.currentThread().getContextClassLoader());
            } else {
                return (Class<T>) Class.forName(name);
            }
        } catch (ClassNotFoundException e) {
            for (ClassLoader l : loaders) {
                try {
                    return (Class<T>) Class.forName(name, true, l);
                } catch (ClassNotFoundException ex) {

                }
            }
        }
        if (Thread.currentThread().getContextClassLoader() != null) {
            throw new ClassNotFoundException("Could not load class " + name +
                    " with the context class loader " + Thread.currentThread().getContextClassLoader().toString() +
                    " or any of the additional ClassLoaders: " + Arrays.toString(loaders));
        } else {
            throw new ClassNotFoundException("Could not load class " + name +
                    " using Class.forName or using any of the additional ClassLoaders: " +
                    Arrays.toString(loaders));
        }
    }

containsWildcards()

static boolean org.keycloak.common.util.reflections.Reflections.containsWildcards ( Type []  types )

inlinestatic

                                                          {
        for (Type type : types) {
            if (type instanceof WildcardType) {
                return true;
            }
        }
        return false;
    }

findDeclaredConstructor()

static Constructor<?> org.keycloak.common.util.reflections.Reflections.findDeclaredConstructor ( Class<?>  clazz, Class<?>...  args  )

inlinestatic

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.

引数

clazz	The class to search
args	The arguments of the constructor to search for

戻り値

The constructor found, or null if no constructor is found

                                                                                           {
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            try {
                return c.getDeclaredConstructor(args);
            } catch (NoSuchMethodException e) {
                // No-op, continue the search
            }
        }
        return null;
    }

findDeclaredField()

static Field org.keycloak.common.util.reflections.Reflections.findDeclaredField ( Class<?>  clazz, String  name  )

inlinestatic

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.

引数

clazz	The class to search
name	The name of the field to search for

戻り値

The field found, or null if no field is found

                                                                       {
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            try {
                return c.getDeclaredField(name);
            } catch (NoSuchFieldException e) {
                // No-op, we continue looking up the class hierarchy
            }
        }
        return null;
    }

findDeclaredMethod()

static Method org.keycloak.common.util.reflections.Reflections.findDeclaredMethod ( Class<?>  clazz, String  name, Class<?>...  args  )

inlinestatic

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.

引数

clazz	The class to search
name	The name of the method to search for
args	The arguments of the method to search for

戻り値

The method found, or null if no method is found

                                                                                           {
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            try {
                return c.getDeclaredMethod(name, args);
            } catch (NoSuchMethodException e) {
                // No-op, continue the search
            }
        }
        return null;
    }

getAllDeclaredConstructors()

static Set<Constructor<?> > org.keycloak.common.util.reflections.Reflections.getAllDeclaredConstructors ( Class<?>  clazz )

inlinestatic

Get all the declared constructors on the class hierarchy. This will return overridden constructors.

引数

clazz

The class to search

戻り値

the set of all declared constructors or an empty set if there are none

                                                                                 {
        HashSet<Constructor<?>> constructors = new HashSet<Constructor<?>>();
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            for (Constructor<?> constructor : c.getDeclaredConstructors()) {
                constructors.add(constructor);
            }
        }
        return constructors;
    }

getAllDeclaredFields()

static Set<Field> org.keycloak.common.util.reflections.Reflections.getAllDeclaredFields ( Class<?>  clazz )

inlinestatic

Get all the declared fields on the class hierarchy. This will return overridden fields.

引数

clazz

The class to search

戻り値

the set of all declared fields or an empty set if there are none

                                                                  {
        HashSet<Field> fields = new HashSet<Field>();
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            for (Field a : c.getDeclaredFields()) {
                fields.add(a);
            }
        }
        return fields;
    }

getAllDeclaredMethods()

static Set<Method> org.keycloak.common.util.reflections.Reflections.getAllDeclaredMethods ( Class<?>  clazz )

inlinestatic

Get all the declared methods on the class hierarchy. This will return overridden methods.

引数

clazz

The class to search

戻り値

the set of all declared methods or an empty set if there are none

                                                                    {
        HashSet<Method> methods = new HashSet<Method>();
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            for (Method a : c.getDeclaredMethods()) {
                methods.add(a);
            }
        }
        return methods;
    }

getAnnotationsWithMetaAnnotation()

static Set<Annotation> org.keycloak.common.util.reflections.Reflections.getAnnotationsWithMetaAnnotation ( Set< Annotation >  annotations, Class<? extends Annotation >  metaAnnotationType  )

inlinestatic

Search for annotations with the specified meta annotation type

引数

annotations	The annotation set to search
metaAnnotationType	The type of the meta annotation to search for

戻り値

The set of annotations with the specified meta annotation, or an empty set if none are found

                                                                                         {
        Set<Annotation> set = new HashSet<Annotation>();
        for (Annotation annotation : annotations) {
            if (annotation.annotationType().isAnnotationPresent(metaAnnotationType)) {
                set.add(annotation);
            }
        }
        return set;
    }

getFieldValue() [1/2]

static Object org.keycloak.common.util.reflections.Reflections.getFieldValue ( Field  field, Object  instance  )

inlinestatic

                                                                     {
        return getFieldValue(field, instance, Object.class);
    }

getFieldValue() [2/2]

static <T> T org.keycloak.common.util.reflections.Reflections.getFieldValue ( Field  field, Object  instance, Class< T >  expectedType  )

inlinestatic

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.

引数

<T>	the type of the field's value
field	the field to operate on
instance	the instance from which to retrieve the value
expectedType	the expected type of the field's value

戻り値

the value of the field

例外

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.

                                                                                           {
        try {
            return Reflections.cast(field.get(instance));
        } catch (IllegalAccessException e) {
            throw new RuntimeException(buildGetFieldValueErrorMessage(field, instance), e);
        } catch (NullPointerException ex) {
            NullPointerException ex2 = new NullPointerException(buildGetFieldValueErrorMessage(field, instance));
            ex2.initCause(ex.getCause());
            throw ex2;
        } catch (ExceptionInInitializerError e) {
            ExceptionInInitializerError e2 = new ExceptionInInitializerError(
                    buildGetFieldValueErrorMessage(field, instance));
            e2.initCause(e.getCause());
            throw e2;
        }
    }

getMemberType()

static Class<?> org.keycloak.common.util.reflections.Reflections.getMemberType ( Member  member )

inlinestatic

Get the type of the member

引数

member

The member

戻り値

The type of the member

例外

UnsupportedOperationException

if the member is not a field, method, or constructor

                                                        {
        if (member instanceof Field) {
            return ((Field) member).getType();
        } else if (member instanceof Method) {
            return ((Method) member).getReturnType();
        } else if (member instanceof Constructor<?>) {
            return ((Constructor<?>) member).getDeclaringClass();
        } else {
            throw new UnsupportedOperationException("Cannot operate on a member of type " + member.getClass());
        }
    }

getNesting()

static int org.keycloak.common.util.reflections.Reflections.getNesting ( Class<?>  clazz )

inlinestatic

                                                 {
        if (clazz.isMemberClass() && !isStatic(clazz)) {
            return 1 + getNesting(clazz.getDeclaringClass());
        } else {
            return 0;
        }
    }

getNonPrivateFinalMethodOrType()

static Object org.keycloak.common.util.reflections.Reflections.getNonPrivateFinalMethodOrType ( Class<?>  type )

inlinestatic

                                                                       {
        if (isFinal(type)) {
            return type;
        }
        for (Method method : type.getDeclaredMethods()) {
            if (isFinal(method) && !isPrivate(method)) {
                return method;
            }
        }
        return null;
    }

getPropertyName()

static String org.keycloak.common.util.reflections.Reflections.getPropertyName ( Method  method )

inlinestatic

Gets the property name from a getter method.

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

引数

method

The getter method

戻り値

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

                                                        {
        String methodName = method.getName();
        if (methodName.matches("^(get).*")) {
            return Introspector.decapitalize(methodName.substring(3));
        } else if (methodName.matches("^(is).*")) {
            return Introspector.decapitalize(methodName.substring(2));
        } else {
            return null;
        }

    }

getRawType()

static <T> Class<T> org.keycloak.common.util.reflections.Reflections.getRawType ( Type  type )

inlinestatic

Extract the raw type, given a type.

引数

<T>	the type
type	the type to extract the raw type from

戻り値

the raw type, or null if the raw type cannot be determined.

                                                     {
        if (type instanceof Class<?>) {
            return (Class<T>) type;
        } else if (type instanceof ParameterizedType) {
            if (((ParameterizedType) type).getRawType() instanceof Class<?>) {
                return (Class<T>) ((ParameterizedType) type).getRawType();
            }
        }
        return null;
    }

invokeMethod() [1/4]

static Object org.keycloak.common.util.reflections.Reflections.invokeMethod ( Method  method, Object  instance, Object...  args  )

inlinestatic

Invoke the specified method on the provided instance, passing any additional arguments included in this method as arguments to the specified method.

This method provides the same functionality and throws the same exceptions as Reflections#invokeMethod(boolean, Method, Class, Object, Object...), with the expected return type set to Object and no change to the method's accessibility.

参照

Reflections::invokeMethod(boolean, Method, Class, Object, Object...)

Method::invoke(Object, Object...)

                                                                                      {
        return invokeMethod(false, method, Object.class, instance, args);
    }

invokeMethod() [2/4]

static Object org.keycloak.common.util.reflections.Reflections.invokeMethod ( boolean  setAccessible, Method  method, Object  instance, Object...  args  )

inlinestatic

Invoke the specified method on the provided instance, passing any additional arguments included in this method as arguments to the specified method.

This method attempts to set the accessible flag of the method in a {link PrivilegedAction} before invoking the method if the first argument is true.

This method provides the same functionality and throws the same exceptions as Method, Class, Object, Object...), with the expected return type set to Object.

参照

Reflections::invokeMethod(boolean, Method, Class, Object, Object...)

Method::invoke(Object, Object...)

                                                                                                             {
        return invokeMethod(setAccessible, method, Object.class, instance, args);
    }

invokeMethod() [3/4]

static <T> T org.keycloak.common.util.reflections.Reflections.invokeMethod ( Method  method, Class< T >  expectedReturnType, Object  instance, Object...  args  )

inlinestatic

Invoke the specified method on the provided instance, passing any additional arguments included in this method as arguments to the specified method.

This method provides the same functionality and throws the same exceptions as Reflections#invokeMethod(boolean, Method, Class, Object, Object...), with the expected return type set to Object and honoring the accessibility of the method.

参照

Reflections::invokeMethod(boolean, Method, Class, Object, Object...)

Method::invoke(Object, Object...)

                                                                                                                  {
        return invokeMethod(false, method, expectedReturnType, instance, args);
    }

invokeMethod() [4/4]

static <T> T org.keycloak.common.util.reflections.Reflections.invokeMethod ( boolean  setAccessible, Method  method, Class< T >  expectedReturnType, Object  instance, Object...  args  )

inlinestatic

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.

引数

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

戻り値

the result of invoking the method, or null if the method's return type is void

例外

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.

参照

Method::invoke(Object, Object...)

                                                                                                   {
        if (setAccessible && !method.isAccessible()) {
            setAccessible(method);
        }

        try {
            return expectedReturnType.cast(method.invoke(instance, args));
        } catch (IllegalAccessException ex) {
            throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex);
        } catch (IllegalArgumentException ex) {
            throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, instance, args), ex);
        } catch (InvocationTargetException ex) {
            throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex.getCause());
        } catch (NullPointerException ex) {
            NullPointerException ex2 = new NullPointerException(buildInvokeMethodErrorMessage(method, instance, args));
            ex2.initCause(ex.getCause());
            throw ex2;
        } catch (ExceptionInInitializerError e) {
            ExceptionInInitializerError e2 = new ExceptionInInitializerError(
                    buildInvokeMethodErrorMessage(method, instance, args));
            e2.initCause(e.getCause());
            throw e2;
        }
    }

isAbstract()

static boolean org.keycloak.common.util.reflections.Reflections.isAbstract ( Method  method )

inlinestatic

Checks if a method is abstract

引数

method

戻り値

                                                    {
        return Modifier.isAbstract(method.getModifiers());
    }

isArrayType()

static boolean org.keycloak.common.util.reflections.Reflections.isArrayType ( Class<?>  rawType )

inlinestatic

Checks if raw type is array type

引数

rawType

The raw type to check

戻り値

True if array, false otherwise

                                                        {
        return rawType.isArray();
    }

isAssignableFrom() [1/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Class<?>  rawType1, Type []  actualTypeArguments1, Class<?>  rawType2, Type []  actualTypeArguments2  )

inlinestatic

Check the assignability of one type to another, taking into account the actual type arguements

引数

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

戻り値

                                                                                           {
        return Types.boxedClass(rawType1).isAssignableFrom(Types.boxedClass(rawType2)) &&
                isAssignableFrom(actualTypeArguments1, actualTypeArguments2);
    }

isAssignableFrom() [2/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Type []  actualTypeArguments1, Type []  actualTypeArguments2  )

inlinestatic

                                                                                                     {
        for (int i = 0; i < actualTypeArguments1.length; i++) {
            Type type1 = actualTypeArguments1[i];
            Type type2 = Object.class;
            if (actualTypeArguments2.length > i) {
                type2 = actualTypeArguments2[i];
            }
            if (!isAssignableFrom(type1, type2)) {
                return false;
            }
        }
        return true;
    }

isAssignableFrom() [3/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Type  type1, Set<? extends Type >  types2  )

inlinestatic

                                                                                   {
        for (Type type2 : types2) {
            if (isAssignableFrom(type1, type2)) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [4/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Type  type1, Type []  types2  )

inlinestatic

                                                                      {
        for (Type type2 : types2) {
            if (isAssignableFrom(type1, type2)) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [5/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Type  type1, Type  type2  )

inlinestatic

                                                                   {
        if (type1 instanceof Class<?>) {
            Class<?> clazz = (Class<?>) type1;
            if (isAssignableFrom(clazz, EMPTY_TYPES, type2)) {
                return true;
            }
        }
        if (type1 instanceof ParameterizedType) {
            ParameterizedType parameterizedType1 = (ParameterizedType) type1;
            if (parameterizedType1.getRawType() instanceof Class<?>) {
                if (isAssignableFrom((Class<?>) parameterizedType1.getRawType(),
                        parameterizedType1.getActualTypeArguments(), type2)) {
                    return true;
                }
            }
        }
        if (type1 instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type1;
            if (isTypeBounded(type2, wildcardType.getLowerBounds(), wildcardType.getUpperBounds())) {
                return true;
            }
        }
        if (type2 instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type2;
            if (isTypeBounded(type1, wildcardType.getUpperBounds(), wildcardType.getLowerBounds())) {
                return true;
            }
        }
        if (type1 instanceof TypeVariable<?>) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type1;
            if (isTypeBounded(type2, EMPTY_TYPES, typeVariable.getBounds())) {
                return true;
            }
        }
        if (type2 instanceof TypeVariable<?>) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
            if (isTypeBounded(type1, typeVariable.getBounds(), EMPTY_TYPES)) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [6/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Class<?>  rawType1, Type []  actualTypeArguments1, Type  type2  )

inlinestatic

                                                                                                       {
        if (type2 instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type2;
            if (parameterizedType.getRawType() instanceof Class<?>) {
                if (isAssignableFrom(rawType1, actualTypeArguments1, (Class<?>) parameterizedType.getRawType(),
                        parameterizedType.getActualTypeArguments())) {
                    return true;
                }
            }
        } else if (type2 instanceof Class<?>) {
            Class<?> clazz = (Class<?>) type2;
            if (isAssignableFrom(rawType1, actualTypeArguments1, clazz, EMPTY_TYPES)) {
                return true;
            }
        } else if (type2 instanceof TypeVariable<?>) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
            if (isTypeBounded(rawType1, actualTypeArguments1, typeVariable.getBounds())) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [7/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Set< Type >  types1, Set< Type >  types2  )

inlinestatic

Check the assiginability of a set of flattened types. This algorithm will check whether any of the types1 matches a type in types2

引数

types1
types2

戻り値

                                                                               {
        for (Type type : types1) {
            if (isAssignableFrom(type, types2)) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [8/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Set< Type >  types1, Type  type2  )

inlinestatic

Check the assignability of a set of flattened types. This algorithm will check whether any of the types1 matches a type in types2

引数

types1
type2

戻り値

                                                                         {
        for (Type type : types1) {
            if (isAssignableFrom(type, type2)) {
                return true;
            }
        }
        return false;
    }

isAssignableFrom() [9/9]

static boolean org.keycloak.common.util.reflections.Reflections.isAssignableFrom ( Type []  types1, Type  type2  )

inlinestatic

                                                                      {
        for (Type type : types1) {
            if (isAssignableFrom(type, type2)) {
                return true;
            }
        }
        return false;
    }

isCacheable() [1/2]

static boolean org.keycloak.common.util.reflections.Reflections.isCacheable ( Set< Annotation >  annotations )

inlinestatic

                                                                   {
        for (Annotation qualifier : annotations) {
            Class<?> clazz = qualifier.getClass();
            if (clazz.isAnonymousClass() || (clazz.isMemberClass() && isStatic(clazz))) {
                return false;
            }
        }
        return true;
    }

isCacheable() [2/2]

static boolean org.keycloak.common.util.reflections.Reflections.isCacheable ( Annotation []  annotations )

inlinestatic

                                                                {
        for (Annotation qualifier : annotations) {
            Class<?> clazz = qualifier.getClass();
            if (clazz.isAnonymousClass() || (clazz.isMemberClass() && isStatic(clazz))) {
                return false;
            }
        }
        return true;
    }

isFinal() [1/2]

static boolean org.keycloak.common.util.reflections.Reflections.isFinal ( Class<?>  clazz )

inlinestatic

Checks if class is final

引数

clazz

The class to check

戻り値

True if final, false otherwise

                                                  {
        return Modifier.isFinal(clazz.getModifiers());
    }

isFinal() [2/2]

static boolean org.keycloak.common.util.reflections.Reflections.isFinal ( Member  member )

inlinestatic

Checks if member is final

引数

member

The member to check

戻り値

True if final, false otherwise

                                                 {
        return Modifier.isFinal(member.getModifiers());
    }

isPackagePrivate()

static boolean org.keycloak.common.util.reflections.Reflections.isPackagePrivate ( int  mod )

inlinestatic

                                                    {
        return !(Modifier.isPrivate(mod) || Modifier.isProtected(mod) || Modifier.isPublic(mod));
    }

isParamerterizedTypeWithWildcard()

static boolean org.keycloak.common.util.reflections.Reflections.isParamerterizedTypeWithWildcard ( Class<?>  type )

inlinestatic

                                                                          {
        if (isParameterizedType(type)) {
            return containsWildcards(type.getTypeParameters());
        } else {
            return false;
        }
    }

isParameterizedType()

static boolean org.keycloak.common.util.reflections.Reflections.isParameterizedType ( Class<?>  type )

inlinestatic

Checks if type is parameterized type

引数

type	The type to check

戻り値

True if parameterized, false otherwise

                                                             {
        return type.getTypeParameters().length > 0;
    }

isPrimitive()

static boolean org.keycloak.common.util.reflections.Reflections.isPrimitive ( Type  type )

inlinestatic

                                                 {
        Class<?> rawType = getRawType(type);
        return rawType == null ? false : rawType.isPrimitive();
    }

isPrivate()

static boolean org.keycloak.common.util.reflections.Reflections.isPrivate ( Member  member )

inlinestatic

Checks if member is private

引数

member

The member to check

戻り値

True if final, false otherwise

                                                   {
        return Modifier.isPrivate(member.getModifiers());
    }

isSerializable()

static boolean org.keycloak.common.util.reflections.Reflections.isSerializable ( Class<?>  clazz )

inlinestatic

Check if a class is serializable.

引数

clazz

The class to check

戻り値

true if the class implements serializable or is a primitive

                                                         {
        return clazz.isPrimitive() || Serializable.class.isAssignableFrom(clazz);
    }

isStatic() [1/2]

static boolean org.keycloak.common.util.reflections.Reflections.isStatic ( Class<?>  type )

inlinestatic

Checks if type is static

引数

type	Type to check

戻り値

True if static, false otherwise

                                                  {
        return Modifier.isStatic(type.getModifiers());
    }

isStatic() [2/2]

static boolean org.keycloak.common.util.reflections.Reflections.isStatic ( Member  member )

inlinestatic

Checks if member is static

引数

member

Member to check

戻り値

True if static, false otherwise

                                                  {
        return Modifier.isStatic(member.getModifiers());
    }

isTransient()

static boolean org.keycloak.common.util.reflections.Reflections.isTransient ( Member  member )

inlinestatic

                                                     {
        return Modifier.isTransient(member.getModifiers());
    }

isTypeBounded()

static boolean org.keycloak.common.util.reflections.Reflections.isTypeBounded ( Type  type, Type []  lowerBounds, Type []  upperBounds  )

inlinestatic

                                                                                           {
        if (lowerBounds.length > 0) {
            if (!isAssignableFrom(type, lowerBounds)) {
                return false;
            }
        }
        if (upperBounds.length > 0) {
            if (!isAssignableFrom(upperBounds, type)) {
                return false;
            }
        }
        return true;
    }

isTypeOrAnyMethodFinal()

static boolean org.keycloak.common.util.reflections.Reflections.isTypeOrAnyMethodFinal ( Class<?>  type )

inlinestatic

Checks if type or member is final

引数

type	Type or member

戻り値

True if final, false otherwise

                                                                {
        return getNonPrivateFinalMethodOrType(type) != null;
    }

matches() [1/5]

static boolean org.keycloak.common.util.reflections.Reflections.matches ( Class<?>  rawType1, Type []  actualTypeArguments1, Class<?>  rawType2, Type []  actualTypeArguments2  )

inlinestatic

                                                                                  {
        return Types.boxedClass(rawType1).equals(Types.boxedClass(rawType2)) &&
                isAssignableFrom(actualTypeArguments1, actualTypeArguments2);
    }

matches() [2/5]

static boolean org.keycloak.common.util.reflections.Reflections.matches ( Type  type1, Set<? extends Type >  types2  )

inlinestatic

                                                                          {
        for (Type type2 : types2) {
            if (matches(type1, type2)) {
                return true;
            }
        }
        return false;
    }

matches() [3/5]

static boolean org.keycloak.common.util.reflections.Reflections.matches ( Type  type1, Type  type2  )

inlinestatic

                                                          {
        if (type1 instanceof Class<?>) {
            Class<?> clazz = (Class<?>) type1;
            if (matches(clazz, EMPTY_TYPES, type2)) {
                return true;
            }
        }
        if (type1 instanceof ParameterizedType) {
            ParameterizedType parameterizedType1 = (ParameterizedType) type1;
            if (parameterizedType1.getRawType() instanceof Class<?>) {
                if (matches((Class<?>) parameterizedType1.getRawType(),
                        parameterizedType1.getActualTypeArguments(), type2)) {
                    return true;
                }
            }
        }
        if (type1 instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type1;
            if (isTypeBounded(type2, wildcardType.getLowerBounds(), wildcardType.getUpperBounds())) {
                return true;
            }
        }
        if (type2 instanceof WildcardType) {
            WildcardType wildcardType = (WildcardType) type2;
            if (isTypeBounded(type1, wildcardType.getUpperBounds(), wildcardType.getLowerBounds())) {
                return true;
            }
        }
        if (type1 instanceof TypeVariable<?>) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type1;
            if (isTypeBounded(type2, EMPTY_TYPES, typeVariable.getBounds())) {
                return true;
            }
        }
        if (type2 instanceof TypeVariable<?>) {
            TypeVariable<?> typeVariable = (TypeVariable<?>) type2;
            if (isTypeBounded(type1, typeVariable.getBounds(), EMPTY_TYPES)) {
                return true;
            }
        }
        return false;
    }

matches() [4/5]

static boolean org.keycloak.common.util.reflections.Reflections.matches ( Class<?>  rawType1, Type []  actualTypeArguments1, Type  type2  )

inlinestatic

                                                                                              {
        if (type2 instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type2;
            if (parameterizedType.getRawType() instanceof Class<?>) {
                if (matches(rawType1, actualTypeArguments1, (Class<?>) parameterizedType.getRawType(),
                        parameterizedType.getActualTypeArguments())) {
                    return true;
                }
            }
        } else if (type2 instanceof Class<?>) {
            Class<?> clazz = (Class<?>) type2;
            if (matches(rawType1, actualTypeArguments1, clazz, EMPTY_TYPES)) {
                return true;
            }
        }
        return false;
    }

matches() [5/5]

static boolean org.keycloak.common.util.reflections.Reflections.matches ( Set< Type >  types1, Set< Type >  types2  )

inlinestatic

Check whether whether any of the types1 matches a type in types2

引数

types1
types2

戻り値

                                                                      {
        for (Type type : types1) {
            if (matches(type, types2)) {
                return true;
            }
        }
        return false;
    }

methodExists()

static boolean org.keycloak.common.util.reflections.Reflections.methodExists ( Class<?>  clazz, String  name  )

inlinestatic

Determine if a method exists in a specified class hierarchy

引数

clazz	The class to search
name	The name of the method

戻り値

true if a method is found, otherwise false

                                                                    {
        for (Class<?> c = clazz; c != null && c != Object.class; c = c.getSuperclass()) {
            for (Method m : c.getDeclaredMethods()) {
                if (m.getName().equals(name)) {
                    return true;
                }
            }
        }
        return false;
    }

newInstance() [1/2]

static <T> T org.keycloak.common.util.reflections.Reflections.newInstance ( final Class< T >  fromClass ) throws ClassNotFoundException, IllegalAccessException, InstantiationException

inlinestatic

Creates a new instance of a class.

This method will use the same class loader of the given class to create the new instance.

引数

fromClass

The class from where the instance should be created.

戻り値

A newly allocated instance of the class.

例外

ClassNotFoundException
IllegalAccessException
InstantiationException

                                                                                                                                            {
        return newInstance(fromClass, fromClass.getName());
    }

newInstance() [2/2]

static <T> T org.keycloak.common.util.reflections.Reflections.newInstance ( final Class<?>  type, final String  fullQualifiedName  ) throws ClassNotFoundException, IllegalAccessException, InstantiationException

inlinestatic

Creates a new instance of a class given its fullQualifiedName.

This method will use the same class loader of type to create the new instance.

引数

type	The class that will be used to get the class loader from.
fullQualifiedName	The full qualified name of the class from which the instance will be created.

戻り値

A newly allocated instance of the class.

例外

ClassNotFoundException
IllegalAccessException
InstantiationException

                                                                                                                                                                       {
        return (T) classForName(fullQualifiedName, type.getClassLoader()).newInstance();
    }

setAccessible()

static <A extends AccessibleObject> A org.keycloak.common.util.reflections.Reflections.setAccessible ( A  member )

inlinestatic

Set the accessibility flag on the AccessibleObject as described in AccessibleObject#setAccessible(boolean) within the context of a {link PrivilegedAction}.

引数

<A>	member the accessible object type
member	the accessible object

戻り値

the accessible object after the accessible flag has been altered

                                                                         {
        AccessController.doPrivileged(new SetAccessiblePrivilegedAction(member));
        return member;
    }

メンバ詳解

EMPTY_ANNOTATION_ARRAY

final Annotation [] org.keycloak.common.util.reflections.Reflections.EMPTY_ANNOTATION_ARRAY = new Annotation[0]

static

An empty array of type java.lang.annotation.Annotation, useful converting lists to arrays.

EMPTY_CLASSES

final Class<?> [] org.keycloak.common.util.reflections.Reflections.EMPTY_CLASSES = new Class<?>[0]

static

EMPTY_OBJECT_ARRAY

final Object [] org.keycloak.common.util.reflections.Reflections.EMPTY_OBJECT_ARRAY = new Object[0]

static

An empty array of type Object, useful for converting lists to arrays.

EMPTY_TYPES

final Type [] org.keycloak.common.util.reflections.Reflections.EMPTY_TYPES = {}

static

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/common/util/reflections/Reflections.java