Module tools.jackson.databind
Package tools.jackson.databind.type

Class TypeFactory

java.lang.Object
tools.jackson.databind.type.TypeFactory
All Implemented Interfaces:
Serializable, Snapshottable<TypeFactory>
public class TypeFactory extends Object implements Snapshottable<TypeFactory>, 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);

Note on optimizations: generic type parameters are resolved for all types, with following exceptions:

  • For optimization purposes, type resolution is skipped for following commonly seen types that do have type parameters, but ones that are rarely needed:
    • Enum: Self-referential type reference is simply dropped and Class is exposed as a simple, non-parameterized SimpleType
    • Comparable: Type parameter is simply dropped and and interface is exposed as a simple, non-parameterized SimpleType
    • Up until Jackson 2.13, Class type parameter was dropped; resolution was added back in Jackson 2.14.
  • For Collection subtypes, resolved type is ALWAYS the parameter for {link java.util.Collection} and not that of actually resolved subtype. This is usually (but not always) same parameter.
  • For Map subtypes, resolved type is ALWAYS the parameter for {link java.util.Map} and not that of actually resolved subtype. These are usually (but not always) same parameters.
See Also:

  • Field Details

    • DEFAULT_MAX_CACHE_SIZE

      public static final int DEFAULT_MAX_CACHE_SIZE
      Default size used to construct _typeCache.
      See Also:

    • EMPTY_BINDINGS

      protected static final TypeBindings EMPTY_BINDINGS

    • CORE_TYPE_BOOL

      protected static final SimpleType CORE_TYPE_BOOL

    • CORE_TYPE_DOUBLE

      protected static final SimpleType CORE_TYPE_DOUBLE

    • CORE_TYPE_INT

      protected static final SimpleType CORE_TYPE_INT

    • CORE_TYPE_LONG

      protected static final SimpleType CORE_TYPE_LONG

    • CORE_TYPE_STRING

      protected static final SimpleType CORE_TYPE_STRING

    • CORE_TYPE_OBJECT

      protected static final SimpleType CORE_TYPE_OBJECT

    • CORE_TYPE_COMPARABLE

      protected static final SimpleType CORE_TYPE_COMPARABLE
      Cache Comparable because it is both parametric (relatively costly to resolve) and mostly useless (no special handling), better handle directly

    • CORE_TYPE_ENUM

      protected static final SimpleType CORE_TYPE_ENUM
      Cache Enum because it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).

    • CORE_TYPE_JSON_NODE

      protected static final SimpleType CORE_TYPE_JSON_NODE
      Cache JsonNode because it is no critical path of simple tree model reading and does not have things to override

    • _typeCache

      protected final LookupCache<Object,JavaType> _typeCache
      Since type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core types

    • _modifiers

      protected final TypeModifier[] _modifiers
      Registered TypeModifiers: objects that can change details of JavaType instances factory constructs.

    • _classLoader

      protected final ClassLoader _classLoader
      ClassLoader used by this factory.

      See [databind#624] for details.

  • Constructor Details

  • Method Details

    • createDefaultInstance

      public static TypeFactory createDefaultInstance()
      Method used to construct a new default/standard TypeFactory instance; an instance which has no custom configuration. Used by ObjectMapper to get the default factory when constructed.
      Since:
      3.0

    • snapshot

      public TypeFactory snapshot()
      Need to make a copy on snapshot() to avoid accidental leakage via cache. In theory only needed if there are modifiers, but since these are lightweight objects, let's recreate always.
      Specified by:
      snapshot in interface Snapshottable<TypeFactory>

    • 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(ClassLoader classLoader)
      "Mutant factory" method which will construct a new instance with specified ClassLoader to use by findClass(java.lang.String).

    • withCache

      public TypeFactory withCache(LookupCache<Object,JavaType> cache)
      Mutant factory method that will construct new TypeFactory with identical settings except for different cache.

    • 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.

    • getClassLoader

      public 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 Class<?> rawClass(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.

    • unsafeSimpleType

      public static JavaType unsafeSimpleType(Class<?> cls)
      Method by core databind for constructing "simple" JavaTypes in cases where there is no access to TypeFactory AND it is known that full resolution of the type is not needed (generally when type is just a placeholder). NOT TO BE USED by application code!
      Since:
      3.0

    • findClass

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

    • classForName

      protected Class<?> classForName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException
      Throws:
      ClassNotFoundException

    • classForName

      protected Class<?> classForName(String name) throws ClassNotFoundException
      Throws:
      ClassNotFoundException

    • _findPrimitive

      protected Class<?> _findPrimitive(String className)

    • constructSpecializedType

      public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass) throws 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:
      IllegalArgumentException

    • constructSpecializedType

      public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass, boolean relaxedCompatibilityCheck) throws 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:
      IllegalArgumentException

    • constructGeneralizedType

      public JavaType constructGeneralizedType(JavaType baseType, Class<?> superClass)
      Method similar to constructSpecializedType(tools.jackson.databind.JavaType, java.lang.Class<?>), but that creates a less-specific type of given type. Usually this is as simple as simply finding super-type with type erasure of superClass, but there may be need for some additional work-arounds.

    • constructFromCanonical

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

    • findTypeParameters

      public JavaType[] findTypeParameters(JavaType type, 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

    • findFirstTypeParameter

      public JavaType findFirstTypeParameter(JavaType type, Class<?> expType)
      Specialized alternative to findTypeParameters(tools.jackson.databind.JavaType, java.lang.Class<?>)
      Since:
      3.0

    • 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

    • constructType

      public JavaType constructType(Type type)

    • constructType

      public JavaType constructType(TypeReference<?> typeRef)

    • resolveMemberType

      public JavaType resolveMemberType(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 sub-type of that type (to bind actual bound type parameters). Not used if type is of type Class<?>.
      Returns:
      Fully resolved type

    • constructArrayType

      public ArrayType constructArrayType(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(Class<? extends Collection> collectionClass, 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(Class<? extends 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(Class<?> collectionClass, 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(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(Class<? extends Map> mapClass, Class<?> keyClass, 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(Class<? extends 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(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)
      Method for constructing a MapLikeType instance.

      Do not use this method to create a true Map type -- use constructMapType(java.lang.Class<? extends java.util.Map>, java.lang.Class<?>, java.lang.Class<?>) instead. Map-like types are only meant for supporting things that do not implement Map interface and as such cannot use standard Map handlers.

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

    • constructMapLikeType

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

      Do not use this method to create a true Map type -- use constructMapType(java.lang.Class<? extends java.util.Map>, java.lang.Class<?>, java.lang.Class<?>) instead. Map-like types are only meant for supporting things that do not implement Map interface and as such cannot use standard Map handlers.

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

    • constructSimpleType

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

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

    • constructReferenceType

      public JavaType constructReferenceType(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.

    • constructParametricType

      public JavaType constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)
      Factory method for constructing JavaType that represents a parameterized type. For example, to represent type Foo<Bar, Baz>, you could call 
        return typeFactory.constructParametricType(Foo.class, Bar.class, Baz.class);
      Parameters:
      parametrized - Type-erased type to parameterize
      parameterClasses - Type parameters to apply

    • constructParametricType

      public JavaType constructParametricType(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);
      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(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:
      3.0

    • constructRawCollectionType

      public CollectionType constructRawCollectionType(Class<? extends 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(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(Class<? extends 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(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.

    • _referenceType

      protected JavaType _referenceType(Class<?> rawClass, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)

    • _constructSimple

      protected JavaType _constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
      Factory method to call when no special JavaType is needed, no generic parameters are passed. Default implementation may check pre-constructed values for "well-known" types, but if none found will simply call _newSimpleType(java.lang.Class<?>, tools.jackson.databind.type.TypeBindings, tools.jackson.databind.JavaType, tools.jackson.databind.JavaType[])

    • _newSimpleType

      protected JavaType _newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
      Factory method that is to create a new SimpleType with no checks whatsoever. Default implementation calls the single argument constructor of SimpleType.

    • _unknownType

      protected JavaType _unknownType()

    • _findWellKnownSimple

      protected static JavaType _findWellKnownSimple(Class<?> clz)
      Helper method called to see if requested, non-generic-parameterized type is one of common, "well-known" types, instances of which are pre-constructed and do not need dynamic caching.

    • _fromAny

      protected JavaType _fromAny(ClassStack context, Type srcType, TypeBindings bindings)
      Factory method that can be used if type information is passed as Java typing returned from getGenericXxx methods (usually for a return or argument type).

    • _applyModifiers

      protected JavaType _applyModifiers(Type srcType, JavaType resolvedType)

    • _fromClass

      protected JavaType _fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)
      Parameters:
      bindings - Mapping of formal parameter declarations (for generic types) into actual types

    • _resolveSuperClass

      protected JavaType _resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings)

    • _resolveSuperInterfaces

      protected JavaType[] _resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings)

    • _fromWellKnownClass

      protected JavaType _fromWellKnownClass(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
      Helper class used to check whether exact class for which type is being constructed is one of well-known base interfaces or classes that indicates alternate JavaType implementation.

    • _fromWellKnownInterface

      protected JavaType _fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)

    • _fromParamType

      protected JavaType _fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings)
      This method deals with parameterized types, that is, first class generic classes.

    • _fromArrayType

      protected JavaType _fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)

    • _fromVariable

      protected JavaType _fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)

    • _fromWildcard

      protected JavaType _fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)