Package com.fasterxml.jackson.databind.type

Class TypeFactory

  • All Implemented Interfaces:
    java.io.Serializable
    public class TypeFactory
extends java.lang.Object
implements java.io.Serializable
    Class used for creating concrete JavaType instances, given various inputs.

    Instances of this class are accessible using ObjectMapper as well as many objects it constructs (like DeserializationConfig and SerializationConfig)), but usually those objects also expose convenience methods (constructType). So, you can do for example: 

       JavaType stringType = mapper.constructType(String.class);
    However, more advanced methods are only exposed by factory so that you may need to use: 
       JavaType stringCollection = mapper.getTypeFactory().constructCollectionType(List.class, String.class);
    See Also:
    Serialized Form

    • Method Detail

      • withModifier

        public TypeFactory withModifier​(TypeModifier mod)
        "Mutant factory" method which will construct a new instance with specified TypeModifier added as the first modifier to call (in case there are multiple registered).

      • withClassLoader

        public TypeFactory withClassLoader​(java.lang.ClassLoader classLoader)
        "Mutant factory" method which will construct a new instance with specified ClassLoader to use by findClass(java.lang.String).

      • withCache

        @Deprecated
public TypeFactory withCache​(LRUMap<java.lang.Object,​JavaType> cache)
        Deprecated.
        Since 2.12
        Mutant factory method that will construct new TypeFactory with identical settings except for different cache; most likely one with bigger maximum size.
        Since:
        2.8

      • withCache

        public TypeFactory withCache​(LookupCache<java.lang.Object,​JavaType> cache)
        Mutant factory method that will construct new TypeFactory with identical settings except for different cache; most likely one with bigger maximum size.
        Since:
        2.12

      • defaultInstance

        public static TypeFactory defaultInstance()
        Method used to access the globally shared instance, which has no custom configuration. Used by ObjectMapper to get the default factory when constructed.

      • clearCache

        public void clearCache()
        Method that will clear up any cached type definitions that may be cached by this TypeFactory instance. This method should not be commonly used, that is, only use it if you know there is a problem with retention of type definitions; the most likely (and currently only known) problem is retention of Class instances via JavaType reference.
        Since:
        2.4.1

      • getClassLoader

        public java.lang.ClassLoader getClassLoader()

      • unknownType

        public static JavaType unknownType()
        Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for java.lang.Object.

      • rawClass

        public static java.lang.Class<?> rawClass​(java.lang.reflect.Type t)
        Static helper method that can be called to figure out type-erased call for given JDK type. It can be called statically since type resolution process can never change actual type-erased class; thereby static default instance is used for determination.

      • findClass

        public java.lang.Class<?> findClass​(java.lang.String className)
                             throws java.lang.ClassNotFoundException
        Low-level lookup method moved from ClassUtil, to allow for overriding of lookup functionality in environments like OSGi.
        Throws:
        java.lang.ClassNotFoundException
        Since:
        2.6

      • constructSpecializedType

        public JavaType constructSpecializedType​(JavaType baseType,
                                         java.lang.Class<?> subclass)
                                  throws java.lang.IllegalArgumentException
        Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by giving HashMap.class as subclass. Short-cut for: 
         constructSpecializedType(baseType, subclass, class);
        that is, will use "strict" compatibility checking, usually used for deserialization purposes (but often not for serialization).
        Throws:
        java.lang.IllegalArgumentException

      • constructSpecializedType

        public JavaType constructSpecializedType​(JavaType baseType,
                                         java.lang.Class<?> subclass,
                                         boolean relaxedCompatibilityCheck)
                                  throws java.lang.IllegalArgumentException
        Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by giving HashMap.class as subclass.
        Parameters:
        baseType - Declared base type with resolved type parameters
        subclass - Runtime subtype to use for resolving
        relaxedCompatibilityCheck - Whether checking for type-assignment compatibility should be "relaxed" (true) or "strict" (false): typically serialization uses relaxed, deserialization strict checking.
        Returns:
        Resolved sub-type
        Throws:
        java.lang.IllegalArgumentException
        Since:
        2.11

      • constructFromCanonical

        public JavaType constructFromCanonical​(java.lang.String canonical)
                                throws java.lang.IllegalArgumentException
        Factory method for constructing a JavaType out of its canonical representation (see ResolvedType.toCanonical()).
        Parameters:
        canonical - Canonical string representation of a type
        Throws:
        java.lang.IllegalArgumentException - If canonical representation is malformed, or class that type represents (including its generic parameters) is not found

      • findTypeParameters

        public JavaType[] findTypeParameters​(JavaType type,
                                     java.lang.Class<?> expType)
        Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. This could mean, for example, trying to figure out key and value types for Map implementations.
        Parameters:
        type - Sub-type (leaf type) that implements expType

      • findTypeParameters

        @Deprecated
public JavaType[] findTypeParameters​(java.lang.Class<?> clz,
                                     java.lang.Class<?> expType,
                                     TypeBindings bindings)
        Deprecated.
        Since 2.7 resolve raw type first, then find type parameters

      • findTypeParameters

        @Deprecated
public JavaType[] findTypeParameters​(java.lang.Class<?> clz,
                                     java.lang.Class<?> expType)
        Deprecated.
        Since 2.7 resolve raw type first, then find type parameters

      • moreSpecificType

        public JavaType moreSpecificType​(JavaType type1,
                                 JavaType type2)
        Method that can be called to figure out more specific of two types (if they are related; that is, one implements or extends the other); or if not related, return the primary type.
        Parameters:
        type1 - Primary type to consider
        type2 - Secondary type to consider
        Since:
        2.2

      • constructType

        public JavaType constructType​(java.lang.reflect.Type type)

      • resolveMemberType

        public JavaType resolveMemberType​(java.lang.reflect.Type type,
                                  TypeBindings contextBindings)
        Method to call when resolving types of Members like Fields, Methods and Constructor parameters and there is a TypeBindings (that describes binding of type parameters within context) to pass. This is typically used only by code in databind itself.
        Parameters:
        type - Type of a Member to resolve
        contextBindings - Type bindings from the context, often class in which member declared but may be subtype of that type (to bind actual bound type parametrers). Not used if type is of type Class<?>.
        Returns:
        Fully resolve type
        Since:
        2.12 as replacement for deprecated constructType(Type, TypeBindings)

      • constructType

        @Deprecated
public JavaType constructType​(java.lang.reflect.Type type,
                              TypeBindings bindings)
        Deprecated.
        Since 2.12
        Method that you very likely should NOT be using -- you need to know a lot about internal details of TypeBindings and even then it will probably not do what you want. Usually you would instead want to call one of constructXxxType() methods (where Xxx would be "Array", "Collection[Like]", "Map[Like]" or "Parametric").

      • constructType

        @Deprecated
public JavaType constructType​(java.lang.reflect.Type type,
                              java.lang.Class<?> contextClass)
        Deprecated.
        Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)

      • constructType

        @Deprecated
public JavaType constructType​(java.lang.reflect.Type type,
                              JavaType contextType)
        Deprecated.
        Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)

      • constructArrayType

        public ArrayType constructArrayType​(java.lang.Class<?> elementType)
        Method for constructing an ArrayType.

        NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)

      • constructArrayType

        public ArrayType constructArrayType​(JavaType elementType)
        Method for constructing an ArrayType.

        NOTE: type modifiers are NOT called on array type itself; but are called for contained types.

      • constructCollectionType

        public CollectionType constructCollectionType​(java.lang.Class<? extends java.util.Collection> collectionClass,
                                              java.lang.Class<?> elementClass)
        Method for constructing a CollectionType.

        NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

      • constructCollectionType

        public CollectionType constructCollectionType​(java.lang.Class<? extends java.util.Collection> collectionClass,
                                              JavaType elementType)
        Method for constructing a CollectionType.

        NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

      • constructCollectionLikeType

        public CollectionLikeType constructCollectionLikeType​(java.lang.Class<?> collectionClass,
                                                      java.lang.Class<?> elementClass)
        Method for constructing a CollectionLikeType.

        NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      • constructCollectionLikeType

        public CollectionLikeType constructCollectionLikeType​(java.lang.Class<?> collectionClass,
                                                      JavaType elementType)
        Method for constructing a CollectionLikeType.

        NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      • constructMapType

        public MapType constructMapType​(java.lang.Class<? extends java.util.Map> mapClass,
                                java.lang.Class<?> keyClass,
                                java.lang.Class<?> valueClass)
        Method for constructing a MapType instance

        NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      • constructMapType

        public MapType constructMapType​(java.lang.Class<? extends java.util.Map> mapClass,
                                JavaType keyType,
                                JavaType valueType)
        Method for constructing a MapType instance

        NOTE: type modifiers are NOT called on constructed type itself.

      • constructMapLikeType

        public MapLikeType constructMapLikeType​(java.lang.Class<?> mapClass,
                                        java.lang.Class<?> keyClass,
                                        java.lang.Class<?> valueClass)
        Method for constructing a MapLikeType instance

        NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      • constructMapLikeType

        public MapLikeType constructMapLikeType​(java.lang.Class<?> mapClass,
                                        JavaType keyType,
                                        JavaType valueType)
        Method for constructing a MapLikeType instance

        NOTE: type modifiers are NOT called on constructed type itself.

      • constructSimpleType

        public JavaType constructSimpleType​(java.lang.Class<?> rawType,
                                    JavaType[] parameterTypes)
        Method for constructing a type instance with specified parameterization.

        NOTE: type modifiers are NOT called on constructed type itself.

      • constructSimpleType

        @Deprecated
public JavaType constructSimpleType​(java.lang.Class<?> rawType,
                                    java.lang.Class<?> parameterTarget,
                                    JavaType[] parameterTypes)
        Deprecated.
        Since 2.7
        Method for constructing a type instance with specified parameterization.
        Since:
        2.6

      • constructReferenceType

        public JavaType constructReferenceType​(java.lang.Class<?> rawType,
                                       JavaType referredType)
        Method for constructing a ReferenceType instance with given type parameter (type MUST take one and only one type parameter)

        NOTE: type modifiers are NOT called on constructed type itself.

        Since:
        2.6

      • uncheckedSimpleType

        @Deprecated
public JavaType uncheckedSimpleType​(java.lang.Class<?> cls)
        Deprecated.
        Since 2.8, to indicate users should never call this method.
        Method that use by core Databind functionality, and that should NOT be called by application code outside databind package.

        Unchecked here not only means that no checks are made as to whether given class might be non-simple type (like CollectionType) but also that most of supertype information is not gathered. This means that unless called on primitive types or String, results are probably not what you want to use.

      • constructParametricType

        public JavaType constructParametricType​(java.lang.Class<?> parametrized,
                                        java.lang.Class<?>... parameterClasses)
        Factory method for constructing JavaType that represents a parameterized type. For example, to represent type List<Set<Integer>>, you could call 
          JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
  return TypeFactory.constructParametricType(List.class, inner);

        NOTE: since 2.11.2 TypeModifiers ARE called on result (fix for [databind#2796])

        Parameters:
        parametrized - Type-erased type to parameterize
        parameterClasses - Type parameters to apply
        Since:
        2.5 NOTE: was briefly deprecated for 2.6

      • constructParametricType

        public JavaType constructParametricType​(java.lang.Class<?> rawType,
                                        JavaType... parameterTypes)
        Factory method for constructing JavaType that represents a parameterized type. For example, to represent type List<Set<Integer>>, you could 
          JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
  return TypeFactory.constructParametricType(List.class, inner);

        NOTE: since 2.11.2 TypeModifiers ARE called on result (fix for [databind#2796])

        Parameters:
        rawType - Actual type-erased type
        parameterTypes - Type parameters to apply
        Returns:
        Fully resolved type for given base type and type parameters

      • constructParametricType

        public JavaType constructParametricType​(java.lang.Class<?> rawType,
                                        TypeBindings parameterTypes)
        Factory method for constructing JavaType that represents a parameterized type. The type's parameters are specified as an instance of TypeBindings. This is useful if you already have the type's parameters such as those found on JavaType. For example, you could call 
           return TypeFactory.constructParametricType(ArrayList.class, javaType.getBindings());
        This effectively applies the parameterized types from one JavaType to another class.
        Parameters:
        rawType - Actual type-erased type
        parameterTypes - Type bindings for the raw type
        Since:
        2.12

      • constructParametrizedType

        @Deprecated
public JavaType constructParametrizedType​(java.lang.Class<?> parametrized,
                                          java.lang.Class<?> parametersFor,
                                          java.lang.Class<?>... parameterClasses)
        Deprecated.
        since 2.9 Use constructParametricType(Class,Class...) instead
        Since:
        2.5

      • constructRawCollectionType

        public CollectionType constructRawCollectionType​(java.lang.Class<? extends java.util.Collection> collectionClass)
        Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown. This is similar to using Object.class parameterization, and is equivalent to calling: 
          typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());

        This method should only be used if parameterization is completely unavailable.

      • constructRawCollectionLikeType

        public CollectionLikeType constructRawCollectionLikeType​(java.lang.Class<?> collectionClass)
        Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown. This is similar to using Object.class parameterization, and is equivalent to calling: 
          typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());

        This method should only be used if parameterization is completely unavailable.

      • constructRawMapType

        public MapType constructRawMapType​(java.lang.Class<? extends java.util.Map> mapClass)
        Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown. This is similar to using Object.class parameterization, and is equivalent to calling: 
          typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

        This method should only be used if parameterization is completely unavailable.

      • constructRawMapLikeType

        public MapLikeType constructRawMapLikeType​(java.lang.Class<?> mapClass)
        Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown. This is similar to using Object.class parameterization, and is equivalent to calling: 
          typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

        This method should only be used if parameterization is completely unavailable.