org.springframework.core

Class ResolvableType

  • java.lang.Object
    • org.springframework.core.ResolvableType
    • Field Detail

      • NONE

        public static final ResolvableType NONE
        ResolvableType returned when no value is available. NONE is used in preference to null so that multiple method calls can be safely chained.
    • Method Detail

      • getType

        public java.lang.reflect.Type getType()
        Return the underling Java Type being managed.
      • getRawClass

        @Nullable
        public java.lang.Class<?> getRawClass()
        Return the underlying Java Class being managed, if available; otherwise null.
      • getSource

        public java.lang.Object getSource()
        Return the underlying source of the resolvable type. Will return a Field, MethodParameter or Type depending on how the ResolvableType was constructed. With the exception of the NONE constant, this method will never return null. This method is primarily to provide access to additional type information or meta-data that alternative JVM languages may provide.
      • toClass

        public java.lang.Class<?> toClass()
        Return this type as a resolved Class, falling back to Object if no specific class can be resolved.
        Returns:
        the resolved Class or the Object fallback
        Since:
        5.1
        See Also:
        getRawClass(), resolve(Class)
      • isInstance

        public boolean isInstance(@Nullable
                                  java.lang.Object obj)
        Determine whether the given object is an instance of this ResolvableType.
        Parameters:
        obj - the object to check
        Since:
        4.2
        See Also:
        isAssignableFrom(Class)
      • isAssignableFrom

        public boolean isAssignableFrom(java.lang.Class<?> other)
        Determine whether this ResolvableType is assignable from the specified other type.
        Parameters:
        other - the type to be checked against (as a Class)
        Since:
        4.2
        See Also:
        isAssignableFrom(ResolvableType)
      • isAssignableFrom

        public boolean isAssignableFrom(ResolvableType other)
        Determine whether this ResolvableType is assignable from the specified other type.

        Attempts to follow the same rules as the Java compiler, considering whether both the resolved Class is assignable from the given type as well as whether all generics are assignable.

        Parameters:
        other - the type to be checked against (as a ResolvableType)
        Returns:
        true if the specified other type can be assigned to this ResolvableType; false otherwise
      • isArray

        public boolean isArray()
        Return true if this type resolves to a Class that represents an array.
        See Also:
        getComponentType()
      • getComponentType

        public ResolvableType getComponentType()
        Return the ResolvableType representing the component type of the array or NONE if this type does not represent an array.
        See Also:
        isArray()
      • asCollection

        public ResolvableType asCollection()
        Convenience method to return this type as a resolvable Collection type. Returns NONE if this type does not implement or extend Collection.
        See Also:
        as(Class), asMap()
      • getInterfaces

        public ResolvableType[] getInterfaces()
        Return a ResolvableType array representing the direct interfaces implemented by this type. If this type does not implement any interfaces an empty array is returned.

        Note: The resulting ResolvableType instances may not be Serializable.

        See Also:
        getSuperType()
      • hasUnresolvableGenerics

        public boolean hasUnresolvableGenerics()
        Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e. without substituting that interface's type variables. The result will be true only in those two scenarios.
      • getNested

        public ResolvableType getNested(int nestingLevel,
                                        @Nullable
                                        java.util.Map<java.lang.Integer,java.lang.Integer> typeIndexesPerLevel)
        Return a ResolvableType for the specified nesting level. The nesting level refers to the specific generic parameter that should be returned. A nesting level of 1 indicates this type; 2 indicates the first nested generic; 3 the second; and so on. For example, given List<Set<Integer>> level 1 refers to the List, level 2 the Set, and level 3 the Integer.

        The typeIndexesPerLevel map can be used to reference a specific generic for the given level. For example, an index of 0 would refer to a Map key; whereas, 1 would refer to the value. If the map does not contain a value for a specific level the last generic will be used (e.g. a Map value).

        Nesting levels may also apply to array types; for example given String[], a nesting level of 2 refers to String.

        If a type does not contain generics the supertype hierarchy will be considered.

        Parameters:
        nestingLevel - the required nesting level, indexed from 1 for the current type, 2 for the first nested generic, 3 for the second and so on
        typeIndexesPerLevel - a map containing the generic index for a given nesting level (may be null)
        Returns:
        a ResolvableType for the nested level or NONE
      • getGeneric

        public ResolvableType getGeneric(@Nullable
                                         int... indexes)
        Return a ResolvableType representing the generic parameter for the given indexes. Indexes are zero based; for example given the type Map<Integer, List<String>>, getGeneric(0) will access the Integer. Nested generics can be accessed by specifying multiple indexes; for example getGeneric(1, 0) will access the String from the nested List. For convenience, if no indexes are specified the first generic is returned.

        If no generic is available at the specified indexes NONE is returned.

        Parameters:
        indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic)
        Returns:
        a ResolvableType for the specified generic or NONE
        See Also:
        hasGenerics(), getGenerics(), resolveGeneric(int...), resolveGenerics()
      • resolveGenerics

        public java.lang.Class<?>[] resolveGenerics()
        Convenience method that will get and resolve generic parameters.
        Returns:
        an array of resolved generic parameters (the resulting array will never be null, but it may contain null elements})
        See Also:
        getGenerics(), resolve()
      • resolveGenerics

        public java.lang.Class<?>[] resolveGenerics(java.lang.Class<?> fallback)
        Convenience method that will get and resolve generic parameters, using the specified fallback if any type cannot be resolved.
        Parameters:
        fallback - the fallback class to use if resolution fails
        Returns:
        an array of resolved generic parameters
        See Also:
        getGenerics(), resolve()
      • resolveGeneric

        @Nullable
        public java.lang.Class<?> resolveGeneric(int... indexes)
        Convenience method that will get and resolve a specific generic parameters.
        Parameters:
        indexes - the indexes that refer to the generic parameter (may be omitted to return the first generic)
        Returns:
        a resolved Class or null
        See Also:
        getGeneric(int...), resolve()
      • resolve

        @Nullable
        public java.lang.Class<?> resolve()
        Resolve this type to a Class, returning null if the type cannot be resolved. This method will consider bounds of TypeVariables and WildcardTypes if direct resolution fails; however, bounds of Object.class will be ignored.

        If this method returns a non-null Class and hasGenerics() returns false, the given type effectively wraps a plain Class, allowing for plain Class processing if desirable.

        Returns:
        the resolved Class, or null if not resolvable
        See Also:
        resolve(Class), resolveGeneric(int...), resolveGenerics()
      • resolve

        public java.lang.Class<?> resolve(java.lang.Class<?> fallback)
        Resolve this type to a Class, returning the specified fallback if the type cannot be resolved. This method will consider bounds of TypeVariables and WildcardTypes if direct resolution fails; however, bounds of Object.class will be ignored.
        Parameters:
        fallback - the fallback class to use if resolution fails
        Returns:
        the resolved Class or the fallback
        See Also:
        resolve(), resolveGeneric(int...), resolveGenerics()
      • equals

        public boolean equals(java.lang.Object other)
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • toString

        public java.lang.String toString()
        Return a String representation of this type in its fully resolved form (including any generic parameters).
        Overrides:
        toString in class java.lang.Object
      • forRawClass

        public static ResolvableType forRawClass(@Nullable
                                                 java.lang.Class<?> clazz)
        Return a ResolvableType for the specified Class, doing assignability checks against the raw class only (analogous to Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for. For example: ResolvableType.forRawClass(List.class).
        Parameters:
        clazz - the class to introspect (null is semantically equivalent to Object.class for typical use cases here}
        Returns:
        a ResolvableType for the specified class
        Since:
        4.2
        See Also:
        forClass(Class), getRawClass()
      • forClass

        public static ResolvableType forClass(java.lang.Class<?> baseType,
                                              java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified base type (interface or base class) with a given implementation class. For example: ResolvableType.forClass(List.class, MyArrayList.class).
        Parameters:
        baseType - the base type (must not be null)
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified base type backed by the given implementation class
        See Also:
        forClass(Class), forClassWithGenerics(Class, Class...)
      • forField

        public static ResolvableType forField(java.lang.reflect.Field field,
                                              java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified Field with a given implementation.

        Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

        Parameters:
        field - the source field
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified field
        See Also:
        forField(Field)
      • forField

        public static ResolvableType forField(java.lang.reflect.Field field,
                                              @Nullable
                                              ResolvableType implementationType)
        Return a ResolvableType for the specified Field with a given implementation.

        Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation type.

        Parameters:
        field - the source field
        implementationType - the implementation type
        Returns:
        a ResolvableType for the specified field
        See Also:
        forField(Field)
      • forField

        public static ResolvableType forField(java.lang.reflect.Field field,
                                              int nestingLevel)
        Return a ResolvableType for the specified Field with the given nesting level.
        Parameters:
        field - the source field
        nestingLevel - the nesting level (1 for the outer level; 2 for a nested generic type; etc)
        See Also:
        forField(Field)
      • forField

        public static ResolvableType forField(java.lang.reflect.Field field,
                                              int nestingLevel,
                                              @Nullable
                                              java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified Field with a given implementation and the given nesting level.

        Use this variant when the class that declares the field includes generic parameter variables that are satisfied by the implementation class.

        Parameters:
        field - the source field
        nestingLevel - the nesting level (1 for the outer level; 2 for a nested generic type; etc)
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified field
        See Also:
        forField(Field)
      • forConstructorParameter

        public static ResolvableType forConstructorParameter(java.lang.reflect.Constructor<?> constructor,
                                                             int parameterIndex,
                                                             java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified Constructor parameter with a given implementation. Use this variant when the class that declares the constructor includes generic parameter variables that are satisfied by the implementation class.
        Parameters:
        constructor - the source constructor (must not be null)
        parameterIndex - the parameter index
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified constructor parameter
        See Also:
        forConstructorParameter(Constructor, int)
      • forMethodReturnType

        public static ResolvableType forMethodReturnType(java.lang.reflect.Method method,
                                                         java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified Method return type. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.
        Parameters:
        method - the source for the method return type
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified method return
        See Also:
        forMethodReturnType(Method)
      • forMethodParameter

        public static ResolvableType forMethodParameter(java.lang.reflect.Method method,
                                                        int parameterIndex,
                                                        java.lang.Class<?> implementationClass)
        Return a ResolvableType for the specified Method parameter with a given implementation. Use this variant when the class that declares the method includes generic parameter variables that are satisfied by the implementation class.
        Parameters:
        method - the source method (must not be null)
        parameterIndex - the parameter index
        implementationClass - the implementation class
        Returns:
        a ResolvableType for the specified method parameter
        See Also:
        forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
      • forArrayComponent

        public static ResolvableType forArrayComponent(ResolvableType componentType)
        Return a ResolvableType as a array of the specified componentType.
        Parameters:
        componentType - the component type
        Returns:
        a ResolvableType as an array of the specified component type
      • clearCache

        public static void clearCache()
        Clear the internal ResolvableType/SerializableTypeWrapper cache.
        Since:
        4.2