public final class TypeFactory extends Object implements Serializable
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);
Modifier and Type | Field and Description |
---|---|
protected ClassLoader |
_classLoader
ClassLoader used by this factory [databind#624].
|
protected TypeModifier[] |
_modifiers
Registered
TypeModifier s: objects that can change details
of JavaType instances factory constructs. |
protected TypeParser |
_parser |
protected LRUMap<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
|
protected static SimpleType |
CORE_TYPE_BOOL |
protected static SimpleType |
CORE_TYPE_CLASS
Cache
Class because it is nominally parametric, but has no really
useful information. |
protected static SimpleType |
CORE_TYPE_COMPARABLE
Cache
Comparable because it is both parameteric (relatively costly to
resolve) and mostly useless (no special handling), better handle directly |
protected static SimpleType |
CORE_TYPE_ENUM
Cache
Enum because it is parametric AND self-referential (costly to
resolve) and useless in itself (no special handling). |
protected static SimpleType |
CORE_TYPE_INT |
protected static SimpleType |
CORE_TYPE_LONG |
protected static SimpleType |
CORE_TYPE_OBJECT |
protected static SimpleType |
CORE_TYPE_STRING |
protected static TypeBindings |
EMPTY_BINDINGS |
protected static TypeFactory |
instance
Globally shared singleton.
|
Modifier | Constructor and Description |
---|---|
protected |
TypeFactory(LRUMap<Object,JavaType> typeCache) |
protected |
TypeFactory(LRUMap<Object,JavaType> typeCache,
TypeParser p,
TypeModifier[] mods,
ClassLoader classLoader) |
Modifier and Type | Method and Description |
---|---|
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. |
protected Class<?> |
_findPrimitive(String className) |
protected 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.
|
protected JavaType |
_fromAny(ClassStack context,
Type type,
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). |
protected JavaType |
_fromArrayType(ClassStack context,
GenericArrayType type,
TypeBindings bindings) |
protected JavaType |
_fromClass(ClassStack context,
Class<?> rawType,
TypeBindings bindings) |
protected JavaType |
_fromParamType(ClassStack context,
ParameterizedType ptype,
TypeBindings parentBindings)
This method deals with parameterized types, that is,
first class generic classes.
|
protected JavaType |
_fromVariable(ClassStack context,
TypeVariable<?> var,
TypeBindings bindings) |
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. |
protected JavaType |
_fromWellKnownInterface(ClassStack context,
Class<?> rawType,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces) |
protected JavaType |
_fromWildcard(ClassStack context,
WildcardType type,
TypeBindings bindings) |
protected JavaType |
_newSimpleType(Class<?> raw,
TypeBindings bindings,
JavaType superClass,
JavaType[] superInterfaces)
Factory method that is to create a new
SimpleType with no
checks whatsoever. |
protected JavaType |
_resolveSuperClass(ClassStack context,
Class<?> rawType,
TypeBindings parentBindings) |
protected JavaType[] |
_resolveSuperInterfaces(ClassStack context,
Class<?> rawType,
TypeBindings parentBindings) |
protected JavaType |
_unknownType() |
protected Class<?> |
classForName(String name) |
protected Class<?> |
classForName(String name,
boolean initialize,
ClassLoader loader) |
void |
clearCache()
Method that will clear up any cached type definitions that may
be cached by this
TypeFactory instance. |
ArrayType |
constructArrayType(Class<?> elementType)
Method for constructing an
ArrayType . |
ArrayType |
constructArrayType(JavaType elementType)
Method for constructing an
ArrayType . |
CollectionLikeType |
constructCollectionLikeType(Class<?> collectionClass,
Class<?> elementClass)
Method for constructing a
CollectionLikeType . |
CollectionLikeType |
constructCollectionLikeType(Class<?> collectionClass,
JavaType elementType)
Method for constructing a
CollectionLikeType . |
CollectionType |
constructCollectionType(Class<? extends Collection> collectionClass,
Class<?> elementClass)
Method for constructing a
CollectionType . |
CollectionType |
constructCollectionType(Class<? extends Collection> collectionClass,
JavaType elementType)
Method for constructing a
CollectionType . |
JavaType |
constructFromCanonical(String canonical)
Factory method for constructing a
JavaType out of its canonical
representation (see ResolvedType.toCanonical() ). |
JavaType |
constructGeneralizedType(JavaType baseType,
Class<?> superClass)
Method similar to
constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>) , but that creates a
less-specific type of given type. |
MapLikeType |
constructMapLikeType(Class<?> mapClass,
Class<?> keyClass,
Class<?> valueClass)
Method for constructing a
MapLikeType instance |
MapLikeType |
constructMapLikeType(Class<?> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapLikeType instance |
MapType |
constructMapType(Class<? extends Map> mapClass,
Class<?> keyClass,
Class<?> valueClass)
Method for constructing a
MapType instance |
MapType |
constructMapType(Class<? extends Map> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a
MapType instance |
JavaType |
constructParametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
constructParametricType(Class<?> rawType,
JavaType... parameterTypes)
Factory method for constructing
JavaType that
represents a parameterized type. |
JavaType |
constructParametrizedType(Class<?> parametrized,
Class<?> parametersFor,
Class<?>... parameterClasses) |
JavaType |
constructParametrizedType(Class<?> parametrized,
Class<?> parametersFor,
JavaType... parameterTypes) |
CollectionLikeType |
constructRawCollectionLikeType(Class<?> collectionClass)
Method that can be used to construct "raw" Collection-like type; meaning that its
parameterization is unknown.
|
CollectionType |
constructRawCollectionType(Class<? extends Collection> collectionClass)
Method that can be used to construct "raw" Collection type; meaning that its
parameterization is unknown.
|
MapLikeType |
constructRawMapLikeType(Class<?> mapClass)
Method that can be used to construct "raw" Map-like type; meaning that its
parameterization is unknown.
|
MapType |
constructRawMapType(Class<? extends Map> mapClass)
Method that can be used to construct "raw" Map type; meaning that its
parameterization is unknown.
|
JavaType |
constructReferenceType(Class<?> rawType,
JavaType referredType) |
JavaType |
constructSimpleType(Class<?> rawType,
Class<?> parameterTarget,
JavaType[] parameterTypes)
Deprecated.
Since 2.7
|
JavaType |
constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization.
|
JavaType |
constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined
by specified subclass; but retaining generic type information if any.
|
JavaType |
constructType(Type type) |
JavaType |
constructType(Type type,
Class<?> contextClass)
Deprecated.
Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
|
JavaType |
constructType(Type type,
JavaType contextType)
Deprecated.
Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
|
JavaType |
constructType(TypeReference<?> typeRef) |
JavaType |
constructType(Type type,
TypeBindings bindings) |
static TypeFactory |
defaultInstance()
Method used to access the globally shared instance, which has
no custom configuration.
|
Class<?> |
findClass(String className)
Low-level lookup method moved from
ClassUtil ,
to allow for overriding of lookup functionality in environments like OSGi. |
JavaType[] |
findTypeParameters(Class<?> clz,
Class<?> expType)
Deprecated.
Since 2.7 resolve raw type first, then find type parameters
|
JavaType[] |
findTypeParameters(Class<?> clz,
Class<?> expType,
TypeBindings bindings)
Deprecated.
Since 2.7 resolve raw type first, then find type parameters
|
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.
|
ClassLoader |
getClassLoader() |
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.
|
static Class<?> |
rawClass(Type t)
Static helper method that can be called to figure out type-erased
call for given JDK type.
|
JavaType |
uncheckedSimpleType(Class<?> cls)
Deprecated.
Since 2.8, to indicate users should never call this method.
|
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 . |
TypeFactory |
withCache(LRUMap<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. |
TypeFactory |
withClassLoader(ClassLoader classLoader) |
TypeFactory |
withModifier(TypeModifier mod) |
protected static final TypeFactory instance
defaultInstance()
for accessing it.protected static final TypeBindings EMPTY_BINDINGS
protected static final SimpleType CORE_TYPE_BOOL
protected static final SimpleType CORE_TYPE_INT
protected static final SimpleType CORE_TYPE_LONG
protected static final SimpleType CORE_TYPE_STRING
protected static final SimpleType CORE_TYPE_OBJECT
protected static final SimpleType CORE_TYPE_COMPARABLE
Comparable
because it is both parameteric (relatively costly to
resolve) and mostly useless (no special handling), better handle directlyprotected static final SimpleType CORE_TYPE_ENUM
Enum
because it is parametric AND self-referential (costly to
resolve) and useless in itself (no special handling).protected static final SimpleType CORE_TYPE_CLASS
Class
because it is nominally parametric, but has no really
useful information.protected final LRUMap<Object,JavaType> _typeCache
protected final TypeModifier[] _modifiers
TypeModifier
s: objects that can change details
of JavaType
instances factory constructs.protected final TypeParser _parser
protected final ClassLoader _classLoader
protected TypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)
public TypeFactory withModifier(TypeModifier mod)
public TypeFactory withClassLoader(ClassLoader classLoader)
public TypeFactory withCache(LRUMap<Object,JavaType> cache)
TypeFactory
with
identical settings except for different cache; most likely one with
bigger maximum size.public static TypeFactory defaultInstance()
ObjectMapper
to
get the default factory when constructed.public void clearCache()
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.public ClassLoader getClassLoader()
public static JavaType unknownType()
java.lang.Object
.public static Class<?> rawClass(Type t)
public Class<?> findClass(String className) throws ClassNotFoundException
ClassUtil
,
to allow for overriding of lookup functionality in environments like OSGi.ClassNotFoundException
protected Class<?> classForName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException
ClassNotFoundException
protected Class<?> classForName(String name) throws ClassNotFoundException
ClassNotFoundException
public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass)
HashMap.class
as subclass.public JavaType constructGeneralizedType(JavaType baseType, Class<?> superClass)
constructSpecializedType(com.fasterxml.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.superClass
- public JavaType constructFromCanonical(String canonical) throws IllegalArgumentException
JavaType
out of its canonical
representation (see ResolvedType.toCanonical()
).canonical
- Canonical string representation of a typeIllegalArgumentException
- If canonical representation is malformed,
or class that type represents (including its generic parameters) is
not foundpublic JavaType[] findTypeParameters(JavaType type, Class<?> expType)
type
- Sub-type (leaf type) that implements expType
@Deprecated public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings)
@Deprecated public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType)
public JavaType moreSpecificType(JavaType type1, JavaType type2)
type1
- Primary type to considertype2
- Secondary type to considerpublic JavaType constructType(Type type, TypeBindings bindings)
public JavaType constructType(TypeReference<?> typeRef)
@Deprecated public JavaType constructType(Type type, Class<?> contextClass)
@Deprecated public JavaType constructType(Type type, JavaType contextType)
public ArrayType constructArrayType(Class<?> elementType)
ArrayType
.
NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)
public ArrayType constructArrayType(JavaType elementType)
ArrayType
.
NOTE: type modifiers are NOT called on array type itself; but are called for contained types.
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)
CollectionType
.
NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
public CollectionType constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)
CollectionType
.
NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)
CollectionLikeType
.
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass, JavaType elementType)
CollectionLikeType
.
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapType constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)
MapType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapType constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)
MapType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)
MapLikeType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public MapLikeType constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)
MapLikeType
instance
NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.
public JavaType constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)
NOTE: was briefly deprecated for 2.6.
@Deprecated public JavaType constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes)
public JavaType constructReferenceType(Class<?> rawType, JavaType referredType)
@Deprecated public JavaType uncheckedSimpleType(Class<?> cls)
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.
public JavaType constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)
JavaType
that
represents a parameterized type. For example, to represent
type List<Set<Integer>>
, you could
call
JavaType inner = TypeFactory.constructParametrizedType(Set.class, Set.class, Integer.class); return TypeFactory.constructParametrizedType(ArrayList.class, List.class, inner);
The reason for first two arguments to be separate is that parameterization may
apply to a super-type. For example, if generic type was instead to be
constructed for ArrayList<Integer>
, the usual call would be:
TypeFactory.constructParametrizedType(ArrayList.class, List.class, Integer.class);since parameterization is applied to
List
.
In most cases distinction does not matter, but there are types where it does;
one such example is parameterization of types that implement Iterator
.
NOTE: type modifiers are NOT called on constructed type.
parametrized
- Actual full typeparameterClasses
- Type parameters to applypublic JavaType constructParametricType(Class<?> rawType, JavaType... parameterTypes)
JavaType
that
represents a parameterized type. For example, to represent
type List<Set<Integer>>
, you could
call
JavaType inner = TypeFactory.constructParametrizedType(Set.class, Set.class, Integer.class); return TypeFactory.constructParametrizedType(ArrayList.class, List.class, inner);
The reason for first two arguments to be separate is that parameterization may
apply to a super-type. For example, if generic type was instead to be
constructed for ArrayList<Integer>
, the usual call would be:
TypeFactory.constructParametrizedType(ArrayList.class, List.class, Integer.class);since parameterization is applied to
List
.
In most cases distinction does not matter, but there are types where it does;
one such example is parameterization of types that implement Iterator
.
NOTE: type modifiers are NOT called on constructed type.
rawType
- Actual type-erased typeparameterTypes
- Type parameters to applypublic JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes)
public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses)
public CollectionType constructRawCollectionType(Class<? extends Collection> collectionClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
public CollectionLikeType constructRawCollectionLikeType(Class<?> collectionClass)
Object.class
parameterization,
and is equivalent to calling:
typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());
This method should only be used if parameterization is completely unavailable.
public MapType constructRawMapType(Class<? extends Map> mapClass)
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.
public MapLikeType constructRawMapLikeType(Class<?> mapClass)
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.
protected JavaType _constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
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<?>, com.fasterxml.jackson.databind.type.TypeBindings, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JavaType[])
protected JavaType _newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
SimpleType
with no
checks whatsoever. Default implementation calls the single argument
constructor of SimpleType
.protected JavaType _unknownType()
protected JavaType _findWellKnownSimple(Class<?> clz)
protected JavaType _fromAny(ClassStack context, Type type, TypeBindings bindings)
getGenericXxx
methods
(usually for a return or argument type).protected JavaType _fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)
bindings
- Mapping of formal parameter declarations (for generic
types) into actual typesprotected JavaType _resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType[] _resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType _fromWellKnownClass(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType
implementation.protected JavaType _fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType _fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings)
protected JavaType _fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)
protected JavaType _fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)
protected JavaType _fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)
Copyright © 2017 JBoss by Red Hat. All rights reserved.