Uses of Class
com.fasterxml.jackson.databind.JavaType

Packages that use JavaType

Package	Description
com.fasterxml.jackson.databind	Basic data binding (mapping) functionality that allows for reading JSON content into Java Objects (POJOs) and JSON Trees (JsonNode), as well as writing Java Objects and trees as JSON.
com.fasterxml.jackson.databind.cfg	Package that contains most of configuration-related classes; exception being couple of most-commonly used configuration things (like Feature enumerations) that are at the main level (com.fasterxml.jackson.databind).
com.fasterxml.jackson.databind.deser	Contains implementation classes of deserialization part of data binding.
com.fasterxml.jackson.databind.deser.impl	Contains those implementation classes of deserialization part of data binding that are not considered part of public or semi-public interfaces.
com.fasterxml.jackson.databind.deser.std	Contains public standard implementations of abstraction that Jackson uses.
com.fasterxml.jackson.databind.exc
com.fasterxml.jackson.databind.ext	Contains extended support for "external" packages: things that may or may not be present in runtime environment, but that are commonly enough used so that explicit support can be added.
com.fasterxml.jackson.databind.introspect	Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
com.fasterxml.jackson.databind.jsonFormatVisitors	Classes used for exposing logical structure of POJOs as Jackson sees it, and exposed via ObjectMapper.acceptJsonFormatVisitor(Class, JsonFormatVisitorWrapper) and ObjectMapper.acceptJsonFormatVisitor(com.fasterxml.jackson.databind.JavaType, JsonFormatVisitorWrapper) methods.
com.fasterxml.jackson.databind.jsontype	Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
com.fasterxml.jackson.databind.jsontype.impl	Package that contains standard implementations for TypeResolverBuilder and TypeIdResolver.
com.fasterxml.jackson.databind.module	Package that contains classes and interfaces to help implement custom extension Modules (which are registered using ObjectMapper.registerModule(com.fasterxml.jackson.databind.Module).
com.fasterxml.jackson.databind.ser	Contains implementation classes of serialization part of data binding.
com.fasterxml.jackson.databind.ser.impl	Contains implementation classes of serialization part of data binding.
com.fasterxml.jackson.databind.ser.std
com.fasterxml.jackson.databind.type	Package that contains concrete implementations of JavaType, as well as the factory (TypeFactory) for constructing instances from various input data types (like Class, Type) and programmatically (for structured types, arrays, Lists and Maps).
com.fasterxml.jackson.databind.util	Utility classes for Mapper package.
com.fasterxml.jackson.datatype.jdk8
com.fasterxml.jackson.datatype.jsr310.ser
com.fasterxml.jackson.jaxrs.cfg
com.fasterxml.jackson.jaxrs.util	Miscellaneous helper classes used by providers.
com.fasterxml.jackson.module.jaxb	Package that contains support for using JAXB annotations for configuring Jackson data-binding aspects.
com.fasterxml.jackson.module.jaxb.ser

Uses of JavaType in com.fasterxml.jackson.databind

Fields in com.fasterxml.jackson.databind declared as JavaType

Modifier and Type	Field and Description
protected JavaType	MappingIterator._type Type to bind individual elements to.
protected JavaType	BeanProperty.Std._type
protected JavaType	BeanDescription._type Bean type information, including raw class and possible generics information
protected JavaType	ObjectReader._valueType Declared type of value to instantiate during deserialization.

Fields in com.fasterxml.jackson.databind with type parameters of type JavaType

Modifier and Type	Field and Description
protected LinkedNode<JavaType>	DeserializationContext._currentType Type of JsonDeserializer (or, more specifically, ContextualDeserializer) that is being contextualized currently.
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>	ObjectReader._rootDeserializers Root-level cached deserializers.
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>	ObjectMapper._rootDeserializers We will use a separate main-level Map for keeping track of root-level deserializers.

Methods in com.fasterxml.jackson.databind that return JavaType

Modifier and Type	Method and Description
protected abstract JavaType	JavaType._narrow(Class<?> subclass) Deprecated.
JavaType	DatabindContext.constructSpecializedType(JavaType baseType, Class<?> subclass) Convenience method for constructing subtypes, retaining generic type parameter (if any)
JavaType	DeserializationContext.constructType(Class<?> cls) Convenience method, functionally equivalent to:
JavaType	ObjectMapper.constructType(Type t) Convenience method for constructing JavaType out of given type (typically java.lang.Class), but without explicit context.
JavaType	DatabindContext.constructType(Type type) Convenience method for constructing JavaType for given JDK type (usually Class)
abstract JavaType	JavaType.containedType(int index)
JavaType	JavaType.containedTypeOrUnknown(int index) Convenience method that is functionally same as: JavaType t = containedType(index); if (t == null) { t = TypeFactory.unknownType(); } and typically used to eliminate need for null checks for common case where we just want to check if containedType is available first; and if not, use "unknown type" (which translates to java.lang.Object basically).
abstract JavaType	JavaType.findSuperType(Class<?> erasedTarget) Method that may be called to find representation of given type within type hierarchy of this type: either this type (if this type has given erased type), one of its supertypes that has the erased types, or null if target is neither this type or any of its supertypes.
JavaType	AbstractTypeResolver.findTypeMapping(DeserializationConfig config, JavaType type) Try to locate a subtype for given abstract type, to either resolve to a concrete type, or at least to a more-specific (and hopefully supported) abstract type, one which may have registered deserializers.
abstract JavaType[]	JavaType.findTypeParameters(Class<?> expType) Method that may be used to find paramaterization this type has for given type-erased generic target type.
JavaType	JavaType.forcedNarrowBy(Class<?> subclass) Deprecated.
JavaType	JavaType.getContentType()
JavaType	DeserializationContext.getContextualType() Accessor to JavaType of currently contextualized ContextualDeserializer, if any.
JavaType	JavaType.getKeyType()
JavaType	JavaType.getReferencedType()
abstract JavaType	JavaType.getSuperClass() Accessor for finding fully resolved parent class of this type, if it has one; null if not.
JavaType	BeanProperty.getType() Method to get declared type of the property.
JavaType	BeanProperty.Std.getType()
JavaType	BeanProperty.Bogus.getType()
JavaType	BeanDescription.getType() Method for accessing declared type of bean being introspected, including full generic type information (from declaration)
JavaType	DeserializationContext.handleMissingTypeId(JavaType baseType, TypeIdResolver idResolver, String extraDesc)
JavaType	DeserializationContext.handleUnknownTypeId(JavaType baseType, String id, TypeIdResolver idResolver, String extraDesc) Method that deserializers should call if they encounter a type id (for polymorphic deserialization) that cannot be resolved to an actual type; usually since there is no mapping defined.
abstract JavaType	JavaType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Mutant factory method that will try to create and return a sub-type instance for known parameterized types; for other types will return `null` to indicate that no just refinement makes necessary sense, without trying to detect special status through implemented interfaces.
JavaType	AnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType) Method called to find out possible type refinements to use for deserialization.
JavaType	AnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType) Method called to find out possible type refinements to use for deserialization, including not just value itself but key and/or content type, if type has those.
JavaType	AbstractTypeResolver.resolveAbstractType(DeserializationConfig config, BeanDescription typeDesc) Method called to try to resolve an abstract type into concrete type (usually for purposes of deserializing), when no concrete implementation was found.
JavaType	AbstractTypeResolver.resolveAbstractType(DeserializationConfig config, JavaType type) Deprecated. since 2.8 (may be removed from 2.9 or later)
JavaType	DatabindContext.resolveSubType(JavaType baseType, String subClass) Lookup method called when code needs to resolve class name from input; usually simple lookup
abstract JavaType	BeanDescription.resolveType(Type jdkType) Deprecated. Since 2.8, should simply call getType of property accessor directly.
abstract JavaType	JavaType.withContentType(JavaType contentType) Mutant factory method that may be called on structured types that have a so-called content type (element of arrays, value type of Maps, referenced type of referential types), and will construct a new instance that is identical to this instance, except that it has specified content type, instead of current one.
abstract JavaType	JavaType.withContentTypeHandler(Object h) Mutant factory method that will construct a new instance that is identical to this instance, except that it will have specified content type (element type for arrays, value type for Maps and so forth) handler assigned.
abstract JavaType	JavaType.withContentValueHandler(Object h) Mutant factory method that will construct a new instance that is identical to this instance, except that it will have specified content value handler assigned.
JavaType	JavaType.withHandlersFrom(JavaType src) Mutant factory method that will try to copy handlers that the specified source type instance had, if any; this must be done recursively where necessary (as content types may be structured).
abstract JavaType	JavaType.withStaticTyping() Method that can be called to get a type instance that indicates that values of the type should be handled using "static typing" for purposes of serialization (as opposed to "dynamic" aka runtime typing): meaning that no runtime information is needed for determining serializers to use.
abstract JavaType	JavaType.withTypeHandler(Object h) "Copy method" that will construct a new instance that is identical to this instance, except that it will have specified type handler assigned.
abstract JavaType	JavaType.withValueHandler(Object h) Mutant factory method that will construct a new instance that is identical to this instance, except that it will have specified value handler assigned.

Methods in com.fasterxml.jackson.databind that return types with arguments of type JavaType

Modifier and Type	Method and Description
abstract List<JavaType>	JavaType.getInterfaces() Accessor for finding fully resolved interfaces this type implements, if any; empty array if none.

Methods in com.fasterxml.jackson.databind with parameters of type JavaType

Modifier and Type	Method and Description
protected Object	ObjectMapper._convert(Object fromValue, JavaType toValueType) Actual conversion implementation: instead of using existing read and write methods, much of code is inlined.
protected JsonSerializer<Object>	SerializerProvider._createAndCacheUntypedSerializer(JavaType type)
protected JsonSerializer<Object>	SerializerProvider._createUntypedSerializer(JavaType type)
protected JsonDeserializer<Object>	ObjectMapper._findRootDeserializer(DeserializationContext ctxt, JavaType valueType) Method called to locate deserializer for the passed root-level value.
protected JsonToken	ObjectMapper._initForReading(JsonParser p, JavaType targetType) Method called to ensure that given parser is ready for reading content for data binding.
protected ObjectReader	ObjectReader._new(ObjectReader base, DeserializationConfig config, JavaType valueType, JsonDeserializer<Object> rootDeser, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues, DataFormatReaders dataFormatReaders) Overridable factory method called by various "withXxx()" methods
protected ObjectReader	ObjectMapper._newReader(DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues) Factory method sub-classes must override, to produce ObjectReader instances of proper sub-type
protected ObjectWriter	ObjectMapper._newWriter(SerializationConfig config, JavaType rootType, PrettyPrinter pp) Factory method sub-classes must override, to produce ObjectWriter instances of proper sub-type
protected JsonDeserializer<Object>	ObjectReader._prefetchRootDeserializer(JavaType valueType) Method called to locate deserializer ahead of time, if permitted by configuration.
protected Object	ObjectMapper._readMapAndClose(JsonParser p0, JavaType valueType)
protected Object	ObjectMapper._readValue(DeserializationConfig cfg, JsonParser p, JavaType valueType) Actual implementation of value reading+binding operation.
protected void	SerializerProvider._reportIncompatibleRootType(Object value, JavaType rootType)
protected Object	ObjectMapper._unwrapAndDeserialize(JsonParser p, DeserializationContext ctxt, DeserializationConfig config, JavaType rootType, JsonDeserializer<Object> deser)
protected Object	ObjectReader._unwrapAndDeserialize(JsonParser p, DeserializationContext ctxt, JavaType rootType, JsonDeserializer<Object> deser)
protected void	ObjectReader._verifyNoTrailingTokens(JsonParser p, DeserializationContext ctxt, JavaType bindType)
protected void	ObjectMapper._verifyNoTrailingTokens(JsonParser p, DeserializationContext ctxt, JavaType bindType)
protected SequenceWriter	SequenceWriter._writeCloseableValue(Object value, JavaType type)
void	ObjectWriter.acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor) Method for visiting type hierarchy for given type, using specified visitor.
void	ObjectMapper.acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor) Method for visiting type hierarchy for given type, using specified visitor.
void	JsonSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType type) Default implementation simply calls JsonFormatVisitorWrapper.expectAnyFormat(JavaType).
TypeDeserializer	ObjectMapper.DefaultTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes)
TypeSerializer	ObjectMapper.DefaultTypeResolverBuilder.buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes)
boolean	ObjectMapper.canDeserialize(JavaType type) Method that can be called to check whether mapper thinks it could deserialize an Object of given type.
boolean	ObjectMapper.canDeserialize(JavaType type, AtomicReference<Throwable> cause) Method similar to ObjectMapper.canDeserialize(JavaType) but that can return actual Throwable that was thrown when trying to construct serializer: this may be useful in figuring out what the actual problem is.
JavaType	DatabindContext.constructSpecializedType(JavaType baseType, Class<?> subclass) Convenience method for constructing subtypes, retaining generic type parameter (if any)
<T> T	ObjectMapper.convertValue(Object fromValue, JavaType toValueType) See ObjectMapper.convertValue(Object, Class)
JsonDeserializer<Object>	DeserializationContext.findContextualValueDeserializer(JavaType type, BeanProperty prop) Method for finding a value deserializer, and creating a contextual version if necessary, for value reached via specified property.
Class<?>	AnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType) Deprecated. Since 2.7 call AnnotationIntrospector.refineDeserializationType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType) instead
Class<?>	AnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType) Deprecated. Since 2.7 call AnnotationIntrospector.refineDeserializationType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType) instead
Class<?>	AnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType) Deprecated. Since 2.7 call AnnotationIntrospector.refineDeserializationType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType) instead
KeyDeserializer	DeserializationContext.findKeyDeserializer(JavaType keyType, BeanProperty prop) Convenience method, functionally same as:
JsonSerializer<Object>	SerializerProvider.findKeySerializer(JavaType keyType, BeanProperty property) Method called to get the serializer to use for serializing non-null Map keys.
JsonDeserializer<Object>	DeserializationContext.findNonContextualValueDeserializer(JavaType type) Variant that will try to locate deserializer for current type, but without performing any contextualization (unlike DeserializationContext.findContextualValueDeserializer(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.BeanProperty)) or checking for need to create a TypeDeserializer (unlike DeserializationContext.findRootValueDeserializer(JavaType).
JsonSerializer<Object>	SerializerProvider.findNullKeySerializer(JavaType serializationType, BeanProperty property) Method called to find a serializer to use for null values for given declared type.
JsonSerializer<Object>	SerializerProvider.findPrimaryPropertySerializer(JavaType valueType, BeanProperty property) Similar to SerializerProvider.findValueSerializer(JavaType, BeanProperty), but used when finding "primary" property value serializer (one directly handling value of the property).
TypeResolverBuilder<?>	AnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType containerType) Method for checking if given structured property entity (field or method that has nominal value of Map, Collection or array type) has annotations that indicate that specific type resolver is to be used for handling type information of contained values.
TypeResolverBuilder<?>	AnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType) Method for checking if given property entity (field or method) has annotations that indicate that specific type resolver is to be used for handling instances.
JsonDeserializer<Object>	DeserializationContext.findRootValueDeserializer(JavaType type) Method for finding a deserializer for root-level value.
Class<?>	AnnotationIntrospector.findSerializationContentType(Annotated am, JavaType baseType) Deprecated. Since 2.7 call AnnotationIntrospector.refineSerializationType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType) instead
Class<?>	AnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType) Deprecated. Since 2.7 call AnnotationIntrospector.refineSerializationType(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated, com.fasterxml.jackson.databind.JavaType) instead
TypeDeserializer	DeserializationConfig.findTypeDeserializer(JavaType baseType) Helper method that is needed to properly handle polymorphic referenced types, such as types referenced by AtomicReference, or various "optional" types.
JsonSerializer<Object>	SerializerProvider.findTypedValueSerializer(JavaType valueType, boolean cache, BeanProperty property) Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence.
JavaType	AbstractTypeResolver.findTypeMapping(DeserializationConfig config, JavaType type) Try to locate a subtype for given abstract type, to either resolve to a concrete type, or at least to a more-specific (and hopefully supported) abstract type, one which may have registered deserializers.
TypeResolverBuilder<?>	AnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType) Method for checking if given class has annotations that indicate that specific type resolver is to be used for handling instances.
TypeSerializer	SerializerProvider.findTypeSerializer(JavaType javaType) Method called to get the TypeSerializer to use for including Type Id necessary for serializing for the given Java class.
JsonSerializer<Object>	SerializerProvider.findValueSerializer(JavaType valueType) Method variant used when we do NOT want contextualization to happen; it will need to be handled at a later point, but caller wants to be able to do that as needed; sometimes to avoid infinite loops
JsonSerializer<Object>	SerializerProvider.findValueSerializer(JavaType valueType, BeanProperty property) Similar to SerializerProvider.findValueSerializer(Class,BeanProperty), but takes full generics-aware type instead of raw class.
ObjectWriter.Prefetch	ObjectWriter.Prefetch.forRootType(ObjectWriter parent, JavaType newType)
ObjectWriter	ObjectWriter.forType(JavaType rootType) Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
ObjectReader	ObjectReader.forType(JavaType valueType) Method for constructing a new reader instance that is configured to data bind into specified type.
JavaType	DeserializationContext.handleMissingTypeId(JavaType baseType, TypeIdResolver idResolver, String extraDesc)
JsonDeserializer<?>	DeserializationContext.handlePrimaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type) Method called for primary property deserializers (ones directly created to deserialize values of a POJO property), to handle details of resolving ContextualDeserializer with given property context.
JsonDeserializer<?>	DeserializationContext.handleSecondaryContextualization(JsonDeserializer<?> deser, BeanProperty prop, JavaType type) Method called for secondary property deserializers (ones NOT directly created to deal with an annotatable POJO property, but instead created as a component -- such as value deserializers for structured types, or deserializers for root values) to handle details of resolving ContextualDeserializer with given property context.
JavaType	DeserializationContext.handleUnknownTypeId(JavaType baseType, String id, TypeIdResolver idResolver, String extraDesc) Method that deserializers should call if they encounter a type id (for polymorphic deserialization) that cannot be resolved to an actual type; usually since there is no mapping defined.
Object	DeserializationContext.handleWeirdNativeValue(JavaType targetType, Object badValue, JsonParser p)
boolean	DeserializationContext.hasValueDeserializerFor(JavaType type, AtomicReference<Throwable> cause) Method for checking whether we could find a deserializer for given type.
<T extends BeanDescription> T	SerializationConfig.introspect(JavaType type) Method that will introspect full bean properties for the purpose of building a bean serializer
<T extends BeanDescription> T	DeserializationConfig.introspect(JavaType type) Method that will introspect full bean properties for the purpose of building a bean deserializer
<T extends BeanDescription> T	DeserializationConfig.introspectForBuilder(JavaType type)
<T extends BeanDescription> T	DeserializationConfig.introspectForCreation(JavaType type) Method that will introspect subset of bean properties needed to construct bean instance.
JsonMappingException	SerializerProvider.invalidTypeIdException(JavaType baseType, String typeId, String extraDesc)
JsonMappingException	DeserializationContext.invalidTypeIdException(JavaType baseType, String typeId, String extraDesc)
protected abstract JsonMappingException	DatabindContext.invalidTypeIdException(JavaType baseType, String typeId, String extraDesc) Helper method for constructing exception to indicate that given type id could not be resolved to a valid subtype of specified base type.
JsonMappingException	DeserializationContext.missingTypeIdException(JavaType baseType, String extraDesc)
ObjectReader	ObjectMapper.reader(JavaType type) Deprecated. Since 2.5, use ObjectMapper.readerFor(JavaType) instead
ObjectReader	ObjectMapper.readerFor(JavaType type) Factory method for constructing ObjectReader that will read or update instances of specified type
<T> T	DeserializationContext.readPropertyValue(JsonParser p, BeanProperty prop, JavaType type)
<T> T	ObjectMapper.readValue(byte[] src, int offset, int len, JavaType valueType)
<T> T	ObjectMapper.readValue(byte[] src, JavaType valueType)
<T> T	ObjectMapper.readValue(DataInput src, JavaType valueType)
<T> T	ObjectMapper.readValue(File src, JavaType valueType) Method to deserialize JSON content from given file into given Java type.
<T> T	ObjectMapper.readValue(InputStream src, JavaType valueType)
<T> T	ObjectReader.readValue(JsonParser p, JavaType valueType) Type-safe overloaded method, basically alias for ObjectReader.readValue(JsonParser, ResolvedType).
<T> T	ObjectMapper.readValue(JsonParser p, JavaType valueType) Type-safe overloaded method, basically alias for ObjectMapper.readValue(JsonParser, Class).
<T> T	DeserializationContext.readValue(JsonParser p, JavaType type)
<T> T	ObjectMapper.readValue(Reader src, JavaType valueType)
<T> T	ObjectMapper.readValue(String content, JavaType valueType) Method to deserialize JSON content from given JSON content String.
<T> T	ObjectMapper.readValue(URL src, JavaType valueType)
<T> Iterator<T>	ObjectReader.readValues(JsonParser p, JavaType valueType) Convenience method that is equivalent to:
<T> MappingIterator<T>	ObjectMapper.readValues(JsonParser p, JavaType valueType) Convenience method, equivalent in function to:
abstract JavaType	JavaType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Mutant factory method that will try to create and return a sub-type instance for known parameterized types; for other types will return `null` to indicate that no just refinement makes necessary sense, without trying to detect special status through implemented interfaces.
abstract JavaType	JavaType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Mutant factory method that will try to create and return a sub-type instance for known parameterized types; for other types will return `null` to indicate that no just refinement makes necessary sense, without trying to detect special status through implemented interfaces.
JavaType	AnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType) Method called to find out possible type refinements to use for deserialization.
JavaType	AnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType) Method called to find out possible type refinements to use for deserialization, including not just value itself but key and/or content type, if type has those.
<T> T	SerializerProvider.reportBadDefinition(JavaType type, String msg)
<T> T	DeserializationContext.reportBadDefinition(JavaType type, String msg)
abstract <T> T	DatabindContext.reportBadDefinition(JavaType type, String msg) Helper method called to indicate a generic problem that stems from type definition(s), not input data, or input/output state; typically this means throwing a InvalidDefinitionException.
<T> T	SerializerProvider.reportBadDefinition(JavaType type, String msg, Throwable cause)
<T> T	DeserializationContext.reportInputMismatch(JavaType targetType, String msg, Object... msgArgs) Helper method used to indicate a problem with input in cases where more specific reportXxx() method was not available.
void	DeserializationContext.reportWrongTokenException(JavaType targetType, JsonToken expToken, String msg, Object... msgArgs) Method for deserializers to call when the token encountered was of type different than what should be seen at that position, usually within a sequence of expected tokens.
JavaType	AbstractTypeResolver.resolveAbstractType(DeserializationConfig config, JavaType type) Deprecated. since 2.8 (may be removed from 2.9 or later)
JavaType	DatabindContext.resolveSubType(JavaType baseType, String subClass) Lookup method called when code needs to resolve class name from input; usually simple lookup
JsonMappingException	DeserializationContext.unknownTypeException(JavaType type, String id, String extraDesc) Deprecated. Since 2.8 use DeserializationContext.handleUnknownTypeId(com.fasterxml.jackson.databind.JavaType, java.lang.String, com.fasterxml.jackson.databind.jsontype.TypeIdResolver, java.lang.String) instead
boolean	ObjectMapper.DefaultTypeResolverBuilder.useForType(JavaType t) Method called to check if the default type handler should be used for given type.
abstract JavaType	JavaType.withContentType(JavaType contentType) Mutant factory method that may be called on structured types that have a so-called content type (element of arrays, value type of Maps, referenced type of referential types), and will construct a new instance that is identical to this instance, except that it has specified content type, instead of current one.
JavaType	JavaType.withHandlersFrom(JavaType src) Mutant factory method that will try to copy handlers that the specified source type instance had, if any; this must be done recursively where necessary (as content types may be structured).
ObjectWriter	ObjectWriter.withType(JavaType rootType) Deprecated. since 2.5 Use ObjectWriter.forType(JavaType) instead
ObjectReader	ObjectReader.withType(JavaType valueType) Deprecated. since 2.5 Use ObjectReader.forType(JavaType) instead
BeanProperty.Std	BeanProperty.Std.withType(JavaType type)
SequenceWriter	SequenceWriter.write(Object value, JavaType type) Method for writing given value into output, as part of sequence to write; further, full type (often generic, like Map is passed in case a new JsonSerializer needs to be fetched to handle type If root type was specified for ObjectWriter, value must be of compatible type (same or subtype).
ObjectWriter	ObjectMapper.writerFor(JavaType rootType) Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value.
ObjectWriter	ObjectMapper.writerWithType(JavaType rootType) Deprecated. Since 2.5, use ObjectMapper.writerFor(JavaType) instead
JsonMappingException	DeserializationContext.wrongTokenException(JsonParser p, JavaType targetType, JsonToken expToken, String extra) Helper method for constructing JsonMappingException to indicate that the token encountered was of type different than what should be seen at that position, usually within a sequence of expected tokens.

Constructors in com.fasterxml.jackson.databind with parameters of type JavaType

Constructor and Description
BeanDescription(JavaType type)
JavaType(JavaType base) Copy-constructor used when refining/upgrading type instances.
MappingIterator(JavaType type, JsonParser p, DeserializationContext ctxt, JsonDeserializer<?> deser, boolean managedParser, Object valueToUpdate)
ObjectReader(ObjectMapper mapper, DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues) Constructor called when a root deserializer should be fetched based on other configuration.
ObjectReader(ObjectReader base, DeserializationConfig config, JavaType valueType, JsonDeserializer<Object> rootDeser, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues, DataFormatReaders dataFormatReaders) Copy constructor used for building variations.
ObjectWriter(ObjectMapper mapper, SerializationConfig config, JavaType rootType, PrettyPrinter pp) Constructor used by ObjectMapper for initial instantiation
Std(BeanProperty.Std base, JavaType newType)
Std(PropertyName name, JavaType type, PropertyName wrapperName, AnnotatedMember member, PropertyMetadata metadata)
Std(PropertyName name, JavaType type, PropertyName wrapperName, Annotations contextAnnotations, AnnotatedMember member, PropertyMetadata metadata) Deprecated. Since 2.9

Uses of JavaType in com.fasterxml.jackson.databind.cfg

Methods in com.fasterxml.jackson.databind.cfg that return JavaType

Modifier and Type	Method and Description
JavaType	MapperConfig.constructSpecializedType(JavaType baseType, Class<?> subclass)
JavaType	MapperConfig.constructType(Class<?> cls) Helper method that will construct JavaType for given raw class.
JavaType	MapperConfig.constructType(TypeReference<?> valueTypeRef) Helper method that will construct JavaType for given type reference This is a simple short-cut for:

Methods in com.fasterxml.jackson.databind.cfg with parameters of type JavaType

Modifier and Type	Method and Description
JavaType	MapperConfig.constructSpecializedType(JavaType baseType, Class<?> subclass)
PropertyName	MapperConfigBase.findRootName(JavaType rootType)
abstract PropertyName	MapperConfig.findRootName(JavaType rootType)
TypeResolverBuilder<?>	MapperConfig.getDefaultTyper(JavaType baseType) Method called to locate a type info handler for types that do not have one explicitly declared via annotations (or other configuration).
BeanDescription	MapperConfig.introspectClassAnnotations(JavaType type) Accessor for getting bean description that only contains class annotations: useful if no getter/setter/creator information is needed.
BeanDescription	MapperConfig.introspectDirectClassAnnotations(JavaType type) Accessor for getting bean description that only contains immediate class annotations: ones from the class, and its direct mix-in, if any, but not from super types.

Uses of JavaType in com.fasterxml.jackson.databind.deser

Fields in com.fasterxml.jackson.databind.deser declared as JavaType

Modifier and Type	Field and Description
protected JavaType	AbstractDeserializer._baseType
protected JavaType	BeanDeserializerBase._beanType Declared type of the bean this deserializer handles.
protected JavaType	BuilderBasedDeserializer._targetType Type that the builder will produce, target type; as opposed to `handledType()` which refers to Builder class.
protected JavaType	SettableBeanProperty._type Base type for property; may be a supertype of actual value.
protected JavaType	SettableAnyProperty._type

Fields in com.fasterxml.jackson.databind.deser with type parameters of type JavaType

Modifier and Type	Field and Description
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>	DeserializerCache._cachedDeserializers We will also cache some dynamically constructed deserializers; specifically, ones that are expensive to construct.
protected HashMap<JavaType,JsonDeserializer<Object>>	DeserializerCache._incompleteDeserializers During deserializer construction process we may need to keep track of partially completed deserializers, to resolve cyclic dependencies.

Methods in com.fasterxml.jackson.databind.deser that return JavaType

Modifier and Type	Method and Description
protected JavaType	BasicDeserializerFactory._findRemappedType(DeserializationConfig config, Class<?> rawType)
JavaType	ValueInstantiator.getArrayDelegateType(DeserializationConfig config) Method that can be used to determine what is the type of array delegate type to use, if any; if no delegates are used, will return null.
JavaType	ValueInstantiator.getDelegateType(DeserializationConfig config) Method that can be used to determine what is the type of delegate type to use, if any; if no delegates are used, will return null.
JavaType	SettableBeanProperty.getType()
JavaType	SettableAnyProperty.getType()
JavaType	BeanDeserializerBase.getValueType()
JavaType	DeserializationProblemHandler.handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver, String failureMsg) Handler method called if an expected type id for a polymorphic value is not found and no "default type" is specified or allowed.
JavaType	DeserializationProblemHandler.handleUnknownTypeId(DeserializationContext ctxt, JavaType baseType, String subTypeId, TypeIdResolver idResolver, String failureMsg) Handler method called if resolution of type id from given String failed to produce a subtype; usually because logical id is not mapped to actual implementation class.
abstract JavaType	DeserializerFactory.mapAbstractType(DeserializationConfig config, JavaType type) Method that can be called to try to resolve an abstract type (interface, abstract class) into a concrete type, or at least something "more concrete" (abstract class instead of interface).
JavaType	BasicDeserializerFactory.mapAbstractType(DeserializationConfig config, JavaType type)
protected JavaType	BeanDeserializerFactory.materializeAbstractType(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)
protected JavaType	BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt, Annotated a, JavaType type) Deprecated. Since 2.8; call BasicDeserializerFactory.resolveMemberAndTypeAnnotations(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.introspect.AnnotatedMember, com.fasterxml.jackson.databind.JavaType) instead
protected JavaType	BasicDeserializerFactory.resolveMemberAndTypeAnnotations(DeserializationContext ctxt, AnnotatedMember member, JavaType type) Helper method used to resolve additional type-related annotation information like type overrides, or handler (serializer, deserializer) overrides, so that from declared field, property or constructor parameter type is used as the base and modified based on annotations, if any.
protected JavaType	BasicDeserializerFactory.resolveType(DeserializationContext ctxt, BeanDescription beanDesc, JavaType type, AnnotatedMember member) Deprecated. since 2.8 call BasicDeserializerFactory.resolveMemberAndTypeAnnotations(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.introspect.AnnotatedMember, com.fasterxml.jackson.databind.JavaType) instead.

Methods in com.fasterxml.jackson.databind.deser with parameters of type JavaType

Modifier and Type	Method and Description
protected JsonDeserializer<Object>	DeserializerCache._createAndCache2(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) Method that handles actual construction (via factory) and caching (both intermediate and eventual)
protected JsonDeserializer<Object>	DeserializerCache._createAndCacheValueDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) Method that will try to create a deserializer for given type, and resolve and cache it if necessary
protected JsonDeserializer<Object>	DeserializerCache._createDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) Method that does the heavy lifting of checking for per-type annotations, find out full type, and figure out which actual factory method to call.
protected JsonDeserializer<?>	DeserializerCache._createDeserializer2(DeserializationContext ctxt, DeserializerFactory factory, JavaType type, BeanDescription beanDesc)
protected JsonDeserializer<Object>	DeserializerCache._findCachedDeserializer(JavaType type)
protected JsonDeserializer<Object>	BasicDeserializerFactory._findCustomBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
protected AnnotatedMethod	BasicDeserializerFactory._findJsonValueFor(DeserializationConfig config, JavaType enumType) Deprecated. since 2.8 call findJsonValueMethod on BeanDescription instead
protected KeyDeserializer	DeserializerCache._handleUnknownKeyDeserializer(DeserializationContext ctxt, JavaType type)
protected JsonDeserializer<Object>	DeserializerCache._handleUnknownValueDeserializer(DeserializationContext ctxt, JavaType type)
protected CollectionType	BasicDeserializerFactory._mapAbstractCollectionType(JavaType type, DeserializationConfig config)
protected void	BeanDeserializerFactory._validateSubType(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)
void	BeanDeserializerBuilder.addInjectable(PropertyName propName, JavaType propType, Annotations contextAnnotations, AnnotatedMember member, Object valueId)
JsonDeserializer<Object>	BeanDeserializerFactory.buildBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Method that is to actually build a bean deserializer instance.
JsonDeserializer<?>	BeanDeserializerBuilder.buildBuilderBased(JavaType valueType, String expBuildMethodName) Method for constructing a specialized deserializer that uses additional external Builder object during data binding.
protected JsonDeserializer<Object>	BeanDeserializerFactory.buildBuilderBasedDeserializer(DeserializationContext ctxt, JavaType valueType, BeanDescription builderDesc) Method for constructing a bean deserializer that uses specified intermediate Builder for binding data, and construction of the value instance.
JsonDeserializer<Object>	BeanDeserializerFactory.buildThrowableDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)
protected SettableBeanProperty	BeanDeserializerFactory.constructSettableProperty(DeserializationContext ctxt, BeanDescription beanDesc, BeanPropertyDefinition propDef, JavaType propType0) Method that will construct a regular bean property setter using the given setter method.
abstract JsonDeserializer<Object>	DeserializerFactory.createBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Method called to create (or, for completely immutable deserializers, reuse) a deserializer that can convert JSON content into values of specified Java "bean" (POJO) type.
JsonDeserializer<Object>	BeanDeserializerFactory.createBeanDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Method that DeserializerCaches call to create a new deserializer for types other than Collections, Maps, arrays and enums.
abstract JsonDeserializer<Object>	DeserializerFactory.createBuilderBasedDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc, Class<?> builderClass) Method called to create a deserializer that will use specified Builder class for building value instances.
JsonDeserializer<Object>	BeanDeserializerFactory.createBuilderBasedDeserializer(DeserializationContext ctxt, JavaType valueType, BeanDescription beanDesc, Class<?> builderClass)
abstract JsonDeserializer<?>	DeserializerFactory.createEnumDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)
JsonDeserializer<?>	BasicDeserializerFactory.createEnumDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Factory method for constructing serializers of Enum types.
abstract KeyDeserializer	DeserializerFactory.createKeyDeserializer(DeserializationContext ctxt, JavaType type) Method called to find if factory knows how to create a key deserializer for specified type; currently this means checking if a module has registered possible deserializers.
KeyDeserializer	BasicDeserializerFactory.createKeyDeserializer(DeserializationContext ctxt, JavaType type)
abstract JsonDeserializer<?>	DeserializerFactory.createTreeDeserializer(DeserializationConfig config, JavaType type, BeanDescription beanDesc) Method called to create and return a deserializer that can construct JsonNode(s) from JSON content.
JsonDeserializer<?>	BasicDeserializerFactory.createTreeDeserializer(DeserializationConfig config, JavaType nodeType, BeanDescription beanDesc)
JsonDeserializer<?>	Deserializers.findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) Method called to locate deserializer for specified value type which does not belong to any other category (not an Enum, Collection, Map, Array, reference value or tree node)
JsonDeserializer<?>	Deserializers.Base.findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
JsonDeserializer<?>	BasicDeserializerFactory.findDefaultDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Helper method called to find one of default serializers for "well-known" platform types: JDK-provided types, and small number of public Jackson API types.
KeyDeserializer	DeserializerCache.findKeyDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) Method called to get hold of a deserializer to use for deserializing keys for Map.
KeyDeserializer	KeyDeserializers.findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
protected JsonDeserializer<?>	BasicDeserializerFactory.findOptionalStdDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Overridable method called after checking all other types.
TypeDeserializer	BasicDeserializerFactory.findPropertyContentTypeDeserializer(DeserializationConfig config, JavaType containerType, AnnotatedMember propertyEntity) Method called to find and create a type information deserializer for values of given container (list, array, map) property, if one is needed.
TypeDeserializer	BasicDeserializerFactory.findPropertyTypeDeserializer(DeserializationConfig config, JavaType baseType, AnnotatedMember annotated) Method called to create a type information deserializer for values of given non-container property, if one is needed.
protected JsonDeserializer<?>	BeanDeserializerFactory.findStdDeserializer(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc) Method called by BeanDeserializerFactory to see if there might be a standard deserializer registered for given type.
abstract TypeDeserializer	DeserializerFactory.findTypeDeserializer(DeserializationConfig config, JavaType baseType) Method called to find and create a type information deserializer for given base type, if one is needed.
TypeDeserializer	BasicDeserializerFactory.findTypeDeserializer(DeserializationConfig config, JavaType baseType)
JsonDeserializer<Object>	DeserializerCache.findValueDeserializer(DeserializationContext ctxt, DeserializerFactory factory, JavaType propertyType) Method called to get hold of a deserializer for a value of given type; or if no such deserializer can be found, a default handler (which may do a best-effort generic serialization or just simply throw an exception when invoked).
JavaType	DeserializationProblemHandler.handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver, String failureMsg) Handler method called if an expected type id for a polymorphic value is not found and no "default type" is specified or allowed.
JavaType	DeserializationProblemHandler.handleUnknownTypeId(DeserializationContext ctxt, JavaType baseType, String subTypeId, TypeIdResolver idResolver, String failureMsg) Handler method called if resolution of type id from given String failed to produce a subtype; usually because logical id is not mapped to actual implementation class.
Object	DeserializationProblemHandler.handleWeirdNativeValue(DeserializationContext ctxt, JavaType targetType, Object valueToConvert, JsonParser p) Method called when an embedded (native) value (JsonToken.VALUE_EMBEDDED_OBJECT) cannot be converted directly into expected value type (usually POJO).
boolean	DeserializerCache.hasValueDeserializerFor(DeserializationContext ctxt, DeserializerFactory factory, JavaType type) Method called to find out whether provider would be able to find a deserializer for given type, using a root reference (i.e.
abstract JavaType	DeserializerFactory.mapAbstractType(DeserializationConfig config, JavaType type) Method that can be called to try to resolve an abstract type (interface, abstract class) into a concrete type, or at least something "more concrete" (abstract class instead of interface).
JavaType	BasicDeserializerFactory.mapAbstractType(DeserializationConfig config, JavaType type)
protected JavaType	BeanDeserializerFactory.materializeAbstractType(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)
JsonDeserializer<?>	BeanDeserializerModifier.modifyEnumDeserializer(DeserializationConfig config, JavaType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer)
KeyDeserializer	BeanDeserializerModifier.modifyKeyDeserializer(DeserializationConfig config, JavaType type, KeyDeserializer deserializer) Method called by DeserializerFactory after it has constructed the standard key deserializer for given key type.
protected JavaType	BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt, Annotated a, JavaType type) Deprecated. Since 2.8; call BasicDeserializerFactory.resolveMemberAndTypeAnnotations(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.introspect.AnnotatedMember, com.fasterxml.jackson.databind.JavaType) instead
protected JavaType	BasicDeserializerFactory.resolveMemberAndTypeAnnotations(DeserializationContext ctxt, AnnotatedMember member, JavaType type) Helper method used to resolve additional type-related annotation information like type overrides, or handler (serializer, deserializer) overrides, so that from declared field, property or constructor parameter type is used as the base and modified based on annotations, if any.
protected JavaType	BasicDeserializerFactory.resolveType(DeserializationContext ctxt, BeanDescription beanDesc, JavaType type, AnnotatedMember member) Deprecated. since 2.8 call BasicDeserializerFactory.resolveMemberAndTypeAnnotations(com.fasterxml.jackson.databind.DeserializationContext, com.fasterxml.jackson.databind.introspect.AnnotatedMember, com.fasterxml.jackson.databind.JavaType) instead.
DataFormatReaders	DataFormatReaders.withType(JavaType type)

Constructors in com.fasterxml.jackson.databind.deser with parameters of type JavaType

Constructor and Description
Base(JavaType type)
BuilderBasedDeserializer(BeanDeserializerBuilder builder, BeanDescription beanDesc, JavaType targetType, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, Set<String> ignorableProps, boolean ignoreAllUnknown, boolean hasViews) Constructor used by BeanDeserializerBuilder.
CreatorProperty(PropertyName name, JavaType type, PropertyName wrapperName, TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedParameter param, int index, Object injectableValueId, PropertyMetadata metadata)
SettableAnyProperty(BeanProperty property, AnnotatedMember setter, JavaType type, JsonDeserializer<Object> valueDeser, TypeDeserializer typeDeser) Deprecated.
SettableAnyProperty(BeanProperty property, AnnotatedMember setter, JavaType type, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer typeDeser)
SettableBeanProperty(BeanPropertyDefinition propDef, JavaType type, TypeDeserializer typeDeser, Annotations contextAnnotations)
SettableBeanProperty(PropertyName propName, JavaType type, PropertyMetadata metadata, JsonDeserializer<Object> valueDeser) Constructor only used by ObjectIdValueProperty.
SettableBeanProperty(PropertyName propName, JavaType type, PropertyName wrapper, TypeDeserializer typeDeser, Annotations contextAnnotations, PropertyMetadata metadata)

Uses of JavaType in com.fasterxml.jackson.databind.deser.impl

Fields in com.fasterxml.jackson.databind.deser.impl declared as JavaType

Modifier and Type	Field and Description
protected JavaType	ObjectIdReader._idType
protected JavaType	BeanAsArrayBuilderDeserializer._targetType Type that the builder will produce, target type; as opposed to `handledType()` which refers to Builder class.
protected JavaType	NullsFailProvider._type

Methods in com.fasterxml.jackson.databind.deser.impl that return JavaType

Modifier and Type	Method and Description
JavaType	ObjectIdReader.getIdType()
JavaType	CreatorCollector.StdTypeConstructor.getParameterType(int index)
JavaType	CreatorCollector.StdTypeConstructor.getType()

Methods in com.fasterxml.jackson.databind.deser.impl with parameters of type JavaType

Modifier and Type	Method and Description
static ExternalTypeHandler.Builder	ExternalTypeHandler.builder(JavaType beanType)
static ObjectIdReader	ObjectIdReader.construct(JavaType idType, PropertyName propName, ObjectIdGenerator<?> generator, JsonDeserializer<?> deser, SettableBeanProperty idProp, ObjectIdResolver resolver) Factory method called by BeanSerializerBase with the initial information based on standard settings for the type for which serializer is being built.
static NullsFailProvider	NullsFailProvider.constructForRootValue(JavaType t)
static JsonDeserializer<?>	JavaUtilCollectionsDeserializers.findForCollection(DeserializationContext ctxt, JavaType type)
static JsonDeserializer<?>	JavaUtilCollectionsDeserializers.findForMap(DeserializationContext ctxt, JavaType type)

Constructors in com.fasterxml.jackson.databind.deser.impl with parameters of type JavaType

Constructor and Description
BeanAsArrayBuilderDeserializer(BeanDeserializerBase delegate, JavaType targetType, SettableBeanProperty[] ordered, AnnotatedMethod buildMethod) Main constructor used both for creating new instances (by BeanDeserializer.asArrayDeserializer()) and for creating copies with different delegate.
Builder(JavaType t)
ExternalTypeHandler(JavaType beanType, com.fasterxml.jackson.databind.deser.impl.ExternalTypeHandler.ExtTypedProperty[] properties, Map<String,Object> nameToPropertyIndex, String[] typeIds, TokenBuffer[] tokens)
FieldProperty(BeanPropertyDefinition propDef, JavaType type, TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedField field)
MethodProperty(BeanPropertyDefinition propDef, JavaType type, TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedMethod method)
NullsFailProvider(PropertyName name, JavaType type)
ObjectIdReader(JavaType t, PropertyName propName, ObjectIdGenerator<?> gen, JsonDeserializer<?> deser, SettableBeanProperty idProp, ObjectIdResolver resolver)
Referring(UnresolvedForwardReference ref, JavaType beanType)
SetterlessProperty(BeanPropertyDefinition propDef, JavaType type, TypeDeserializer typeDeser, Annotations contextAnnotations, AnnotatedMethod method)
ValueInjector(PropertyName propName, JavaType type, AnnotatedMember mutator, Object valueId)
ValueInjector(PropertyName propName, JavaType type, Annotations contextAnnotations, AnnotatedMember mutator, Object valueId) Deprecated. in 2.9 (remove from 3.0)

Uses of JavaType in com.fasterxml.jackson.databind.deser.std

Fields in com.fasterxml.jackson.databind.deser.std declared as JavaType

Modifier and Type	Field and Description
protected JavaType	StdValueInstantiator._arrayDelegateType
protected JavaType	ContainerDeserializerBase._containerType
protected JavaType	StdValueInstantiator._delegateType
protected JavaType	StdDelegatingDeserializer._delegateType Fully resolved delegate type, with generic information if any available.
protected JavaType	EnumSetDeserializer._enumType
protected JavaType	ReferenceTypeDeserializer._fullType Full type of property (or root value) for which this deserializer has been constructed and contextualized.
protected JavaType	UntypedObjectDeserializer._listType If List has been mapped to non-default implementation, we'll store type here
protected JavaType	UntypedObjectDeserializer._mapType If Map has been mapped to non-default implementation, we'll store type here

Methods in com.fasterxml.jackson.databind.deser.std that return JavaType

Modifier and Type	Method and Description
JavaType	StdValueInstantiator.getArrayDelegateType(DeserializationConfig config)
JavaType	MapEntryDeserializer.getContentType()
JavaType	ContainerDeserializerBase.getContentType() Accessor for declared type of contained value elements; either exact type, or one of its supertypes.
JavaType	StdValueInstantiator.getDelegateType(DeserializationConfig config)
JavaType	StdDeserializer.getValueType() Exact structured type this deserializer handles, if known.
JavaType	ReferenceTypeDeserializer.getValueType()
JavaType	MapDeserializer.getValueType()
JavaType	ContainerDeserializerBase.getValueType()

Methods in com.fasterxml.jackson.databind.deser.std with parameters of type JavaType

Modifier and Type	Method and Description
protected JsonDeserializer<Object>	UntypedObjectDeserializer._findCustomDeser(DeserializationContext ctxt, JavaType type)
protected boolean	MapDeserializer._isStdKeyDeser(JavaType mapType, KeyDeserializer keyDeser) Helper method used to check whether we can just use the default key deserialization, where JSON String becomes Java String.
void	StdValueInstantiator.configureFromArraySettings(AnnotatedWithParams arrayDelegateCreator, JavaType arrayDelegateType, SettableBeanProperty[] arrayDelegateArgs)
void	StdValueInstantiator.configureFromObjectSettings(AnnotatedWithParams defaultCreator, AnnotatedWithParams delegateCreator, JavaType delegateType, SettableBeanProperty[] delegateArgs, AnnotatedWithParams withArgsCreator, SettableBeanProperty[] constructorArgs) Method for setting properties related to instantiating values from JSON Object.
static KeyDeserializer	StdKeyDeserializers.constructDelegatingKeyDeserializer(DeserializationConfig config, JavaType type, JsonDeserializer<?> deser)
protected JsonDeserializer<Object>	StdDeserializer.findDeserializer(DeserializationContext ctxt, JavaType type, BeanProperty property) Helper method used to locate deserializers for properties the type this deserializer handles contains (usually for properties of bean types)
KeyDeserializer	StdKeyDeserializers.findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
static KeyDeserializer	StdKeyDeserializers.findStringBasedKeyDeserializer(DeserializationConfig config, JavaType type)
protected StdDelegatingDeserializer<T>	StdDelegatingDeserializer.withDelegate(Converter<Object,T> converter, JavaType delegateType, JsonDeserializer<?> delegateDeserializer) Method used for creating resolved contextual instances.

Constructors in com.fasterxml.jackson.databind.deser.std with parameters of type JavaType

Constructor and Description
ArrayBlockingQueueDeserializer(JavaType containerType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator)
ArrayBlockingQueueDeserializer(JavaType containerType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator, JsonDeserializer<Object> delegateDeser, NullValueProvider nuller, Boolean unwrapSingle) Constructor used when creating contextualized instances.
AtomicReferenceDeserializer(JavaType fullType, ValueInstantiator inst, TypeDeserializer typeDeser, JsonDeserializer<?> deser)
CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator) Constructor for context-free instances, where we do not yet know which property is using this deserializer.
CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator, JsonDeserializer<Object> delegateDeser, NullValueProvider nuller, Boolean unwrapSingle) Constructor used when creating contextualized instances.
ContainerDeserializerBase(JavaType selfType)
ContainerDeserializerBase(JavaType selfType, NullValueProvider nuller, Boolean unwrapSingle)
EnumMapDeserializer(JavaType mapType, KeyDeserializer keyDeser, JsonDeserializer<?> valueDeser, TypeDeserializer vtd) Deprecated.
EnumMapDeserializer(JavaType mapType, ValueInstantiator valueInst, KeyDeserializer keyDeser, JsonDeserializer<?> valueDeser, TypeDeserializer vtd, NullValueProvider nuller)
EnumSetDeserializer(JavaType enumType, JsonDeserializer<?> deser)
MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser)
MapEntryDeserializer(JavaType type, KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser, TypeDeserializer valueTypeDeser)
ObjectArrayDeserializer(JavaType arrayType, JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser)
ReferenceTypeDeserializer(JavaType fullType, TypeDeserializer typeDeser, JsonDeserializer<?> deser) Deprecated.
ReferenceTypeDeserializer(JavaType fullType, ValueInstantiator vi, TypeDeserializer typeDeser, JsonDeserializer<?> deser)
StdDelegatingDeserializer(Converter<Object,T> converter, JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
StdDeserializer(JavaType valueType)
StdNodeBasedDeserializer(JavaType targetType)
StdScalarDeserializer(JavaType valueType)
StdValueInstantiator(DeserializationConfig config, JavaType valueType)
StringCollectionDeserializer(JavaType collectionType, JsonDeserializer<?> valueDeser, ValueInstantiator valueInstantiator)
StringCollectionDeserializer(JavaType collectionType, ValueInstantiator valueInstantiator, JsonDeserializer<?> delegateDeser, JsonDeserializer<?> valueDeser, NullValueProvider nuller, Boolean unwrapSingle)
UntypedObjectDeserializer(JavaType listType, JavaType mapType)

Uses of JavaType in com.fasterxml.jackson.databind.exc

Fields in com.fasterxml.jackson.databind.exc declared as JavaType

Modifier and Type	Field and Description
protected JavaType	InvalidTypeIdException._baseType Basetype for which subtype was to be resolved
protected JavaType	InvalidDefinitionException._type

Methods in com.fasterxml.jackson.databind.exc that return JavaType

Modifier and Type	Method and Description
JavaType	InvalidTypeIdException.getBaseType()
JavaType	InvalidDefinitionException.getType() Accessor for type fully resolved type that had the problem; this should always known and available, never null

Methods in com.fasterxml.jackson.databind.exc with parameters of type JavaType

Modifier and Type	Method and Description
static InvalidNullException	InvalidNullException.from(DeserializationContext ctxt, PropertyName name, JavaType type)
static InvalidDefinitionException	InvalidDefinitionException.from(JsonGenerator g, String msg, JavaType type)
static MismatchedInputException	MismatchedInputException.from(JsonParser p, JavaType targetType, String msg)
static InvalidDefinitionException	InvalidDefinitionException.from(JsonParser p, String msg, JavaType type)
static InvalidTypeIdException	InvalidTypeIdException.from(JsonParser p, String msg, JavaType baseType, String typeId)
MismatchedInputException	MismatchedInputException.setTargetType(JavaType t)

Constructors in com.fasterxml.jackson.databind.exc with parameters of type JavaType

Constructor and Description
InvalidDefinitionException(JsonGenerator g, String msg, JavaType type)
InvalidDefinitionException(JsonParser p, String msg, JavaType type)
InvalidTypeIdException(JsonParser p, String msg, JavaType baseType, String typeId)
MismatchedInputException(JsonParser p, String msg, JavaType targetType)

Uses of JavaType in com.fasterxml.jackson.databind.ext

Methods in com.fasterxml.jackson.databind.ext with parameters of type JavaType

Modifier and Type	Method and Description
void	DOMSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	CoreXMLSerializers.XMLGregorianCalendarSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
JsonDeserializer<?>	CoreXMLDeserializers.findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
JsonDeserializer<?>	OptionalHandlerFactory.findDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
JsonSerializer<?>	OptionalHandlerFactory.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)
JsonSerializer<?>	CoreXMLSerializers.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)

Uses of JavaType in com.fasterxml.jackson.databind.introspect

Fields in com.fasterxml.jackson.databind.introspect declared as JavaType

Modifier and Type	Field and Description
protected JavaType	VirtualAnnotatedMember._type
protected JavaType	POJOPropertiesCollector._type Type of POJO for which properties are being collected.
protected JavaType	AnnotatedParameter._type JDK type of the parameter, possibly contains generic type information
protected JavaType	AnnotatedClass._type

Fields in com.fasterxml.jackson.databind.introspect with type parameters of type JavaType

Modifier and Type	Field and Description
protected LRUMap<JavaType,BasicBeanDescription>	BasicClassIntrospector._cachedFCA Looks like 'forClassAnnotations()' gets called so frequently that we should consider caching to avoid some of the lookups.
protected List<JavaType>	AnnotatedClass._superTypes Ordered set of super classes and interfaces of the class itself: included in order of precedence

Methods in com.fasterxml.jackson.databind.introspect that return JavaType

Modifier and Type	Method and Description
abstract JavaType	AnnotatedWithParams.getParameterType(int index)
JavaType	AnnotatedMethod.getParameterType(int index)
JavaType	AnnotatedConstructor.getParameterType(int index)
JavaType	POJOPropertyBuilder.getPrimaryType() Type determined from the primary member for the property being built, considering precedence according to whether we are processing serialization or deserialization.
abstract JavaType	BeanPropertyDefinition.getPrimaryType()
JavaType	VirtualAnnotatedMember.getType()
JavaType	POJOPropertiesCollector.getType()
JavaType	AnnotatedParameter.getType()
JavaType	AnnotatedMethod.getType() For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence `Void` would be returned here)
JavaType	AnnotatedField.getType()
JavaType	AnnotatedConstructor.getType()
JavaType	AnnotatedClass.getType()
abstract JavaType	Annotated.getType() Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
JavaType	Annotated.getType(TypeBindings bogus) Deprecated. Since 2.7 Use Annotated.getType() instead. To be removed from 2.9
JavaType	JacksonAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	AnnotationIntrospectorPair.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JacksonAnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	AnnotationIntrospectorPair.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	TypeResolutionContext.resolveType(Type t)
JavaType	TypeResolutionContext.Basic.resolveType(Type type)
JavaType	BasicBeanDescription.resolveType(Type jdkType) Deprecated.
JavaType	AnnotatedClass.resolveType(Type type)

Methods in com.fasterxml.jackson.databind.introspect with parameters of type JavaType

Modifier and Type	Method and Description
protected BeanPropertyWriter	JacksonAnnotationIntrospector._constructVirtualProperty(JsonAppend.Attr attr, MapperConfig<?> config, AnnotatedClass ac, JavaType type)
protected BasicBeanDescription	BasicClassIntrospector._findStdJdkCollectionDesc(MapperConfig<?> cfg, JavaType type)
protected BasicBeanDescription	BasicClassIntrospector._findStdTypeDesc(JavaType type) Method called to see if type is one of core JDK types that we have cached for efficiency.
protected TypeResolverBuilder<?>	JacksonAnnotationIntrospector._findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType) Helper method called to construct and initialize instance of TypeResolverBuilder if given annotated element indicates one is needed.
protected boolean	BasicClassIntrospector._isStdJDKCollection(JavaType type) Helper method used to decide whether we can omit introspection for members (methods, fields, constructors); we may do so for a limited number of container types JDK provides.
protected AnnotatedClass	BasicClassIntrospector._resolveAnnotatedClass(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)
protected AnnotatedClass	BasicClassIntrospector._resolveAnnotatedWithoutSuperTypes(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)
static List<AnnotatedField>	AnnotatedFieldCollector.collectFields(AnnotationIntrospector intr, TypeResolutionContext tc, ClassIntrospector.MixInResolver mixins, TypeFactory types, JavaType type)
static AnnotatedMethodMap	AnnotatedMethodCollector.collectMethods(AnnotationIntrospector intr, TypeResolutionContext tc, ClassIntrospector.MixInResolver mixins, TypeFactory types, JavaType type, List<JavaType> superTypes, Class<?> primaryMixIn)
protected POJOPropertiesCollector	BasicClassIntrospector.collectProperties(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r, boolean forSerialization, String mutatorPrefix)
protected POJOPropertiesCollector	BasicClassIntrospector.collectPropertiesWithBuilder(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r, boolean forSerialization)
static AnnotatedClass	AnnotatedClass.construct(JavaType type, MapperConfig<?> config) Deprecated. Since 2.9, use methods in AnnotatedClassResolver instead.
static AnnotatedClass	AnnotatedClass.construct(JavaType type, MapperConfig<?> config, ClassIntrospector.MixInResolver mir) Deprecated. Since 2.9, use methods in AnnotatedClassResolver instead.
protected POJOPropertiesCollector	BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config, AnnotatedClass ac, JavaType type, boolean forSerialization, String mutatorPrefix) Overridable method called for creating POJOPropertiesCollector instance to use; override is needed if a custom sub-class is to be used.
Class<?>	JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType) Deprecated.
Class<?>	AnnotationIntrospectorPair.findDeserializationContentType(Annotated am, JavaType baseContentType) Deprecated.
Class<?>	JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType) Deprecated.
Class<?>	AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am, JavaType baseKeyType) Deprecated.
Class<?>	JacksonAnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType) Deprecated.
Class<?>	AnnotationIntrospectorPair.findDeserializationType(Annotated am, JavaType baseType) Deprecated.
TypeResolverBuilder<?>	JacksonAnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType containerType)
TypeResolverBuilder<?>	AnnotationIntrospectorPair.findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
TypeResolverBuilder<?>	JacksonAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
TypeResolverBuilder<?>	AnnotationIntrospectorPair.findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
Class<?>	JacksonAnnotationIntrospector.findSerializationContentType(Annotated am, JavaType baseType) Deprecated.
Class<?>	AnnotationIntrospectorPair.findSerializationContentType(Annotated am, JavaType baseType) Deprecated.
Class<?>	JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType) Deprecated.
Class<?>	AnnotationIntrospectorPair.findSerializationKeyType(Annotated am, JavaType baseType) Deprecated.
TypeResolverBuilder<?>	JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
TypeResolverBuilder<?>	AnnotationIntrospectorPair.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
abstract BeanDescription	ClassIntrospector.forClassAnnotations(MapperConfig<?> cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that only has information regarding annotations class itself (or its supertypes) has, but nothing on methods or constructors.
BasicBeanDescription	BasicClassIntrospector.forClassAnnotations(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)
abstract BeanDescription	ClassIntrospector.forCreation(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that has information necessary for creating instances of given class ("creator"), as well as class annotations, but no information on member methods
BasicBeanDescription	BasicClassIntrospector.forCreation(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
abstract BeanDescription	ClassIntrospector.forDeserialization(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that has all information needed for deserialization purposes.
BasicBeanDescription	BasicClassIntrospector.forDeserialization(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
abstract BeanDescription	ClassIntrospector.forDeserializationWithBuilder(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that has all information needed for constructing deserializers that use intermediate Builder objects.
BasicBeanDescription	BasicClassIntrospector.forDeserializationWithBuilder(DeserializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
abstract BeanDescription	ClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that only has information regarding annotations class itself has (but NOT including its supertypes), but nothing on methods or constructors.
BasicBeanDescription	BasicClassIntrospector.forDirectClassAnnotations(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)
static BasicBeanDescription	BasicBeanDescription.forOtherUse(MapperConfig<?> config, JavaType type, AnnotatedClass ac) Factory method to use for constructing an instance to use for purposes other than building serializers or deserializers; will only have information on class, not on properties.
abstract BeanDescription	ClassIntrospector.forSerialization(SerializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r) Factory method that constructs an introspector that has all information needed for serialization purposes.
BasicBeanDescription	BasicClassIntrospector.forSerialization(SerializationConfig cfg, JavaType type, ClassIntrospector.MixInResolver r)
JavaType	JacksonAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	AnnotationIntrospectorPair.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JacksonAnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	AnnotationIntrospectorPair.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
static AnnotatedClass	AnnotatedClassResolver.resolve(MapperConfig<?> config, JavaType forType, ClassIntrospector.MixInResolver r)
static AnnotatedClass	AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config, JavaType forType, ClassIntrospector.MixInResolver r)

Method parameters in com.fasterxml.jackson.databind.introspect with type arguments of type JavaType

Modifier and Type	Method and Description
static AnnotatedMethodMap	AnnotatedMethodCollector.collectMethods(AnnotationIntrospector intr, TypeResolutionContext tc, ClassIntrospector.MixInResolver mixins, TypeFactory types, JavaType type, List<JavaType> superTypes, Class<?> primaryMixIn)

Constructors in com.fasterxml.jackson.databind.introspect with parameters of type JavaType

Constructor and Description
AnnotatedParameter(AnnotatedWithParams owner, JavaType type, TypeResolutionContext typeContext, AnnotationMap annotations, int index)
BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass classDef, List<BeanPropertyDefinition> props) Alternate constructor used in cases where property information is not needed, only class info.
BasicBeanDescription(POJOPropertiesCollector coll, JavaType type, AnnotatedClass classDef)
POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization, JavaType type, AnnotatedClass classDef, String mutatorPrefix)
VirtualAnnotatedMember(TypeResolutionContext typeContext, Class<?> declaringClass, String name, JavaType type)

Uses of JavaType in com.fasterxml.jackson.databind.jsonFormatVisitors

Methods in com.fasterxml.jackson.databind.jsonFormatVisitors with parameters of type JavaType

Modifier and Type	Method and Description
void	JsonFormatVisitable.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) Get the representation of the schema to which this serializer will conform.
JsonAnyFormatVisitor	JsonFormatVisitorWrapper.expectAnyFormat(JavaType type)
JsonAnyFormatVisitor	JsonFormatVisitorWrapper.Base.expectAnyFormat(JavaType type)
JsonArrayFormatVisitor	JsonFormatVisitorWrapper.expectArrayFormat(JavaType type)
JsonArrayFormatVisitor	JsonFormatVisitorWrapper.Base.expectArrayFormat(JavaType type)
JsonBooleanFormatVisitor	JsonFormatVisitorWrapper.expectBooleanFormat(JavaType type)
JsonBooleanFormatVisitor	JsonFormatVisitorWrapper.Base.expectBooleanFormat(JavaType type)
JsonIntegerFormatVisitor	JsonFormatVisitorWrapper.expectIntegerFormat(JavaType type)
JsonIntegerFormatVisitor	JsonFormatVisitorWrapper.Base.expectIntegerFormat(JavaType type)
JsonMapFormatVisitor	JsonFormatVisitorWrapper.expectMapFormat(JavaType type) Method called when type is of Java Map type, and will be serialized as a JSON Object.
JsonMapFormatVisitor	JsonFormatVisitorWrapper.Base.expectMapFormat(JavaType type)
JsonNullFormatVisitor	JsonFormatVisitorWrapper.expectNullFormat(JavaType type)
JsonNullFormatVisitor	JsonFormatVisitorWrapper.Base.expectNullFormat(JavaType type)
JsonNumberFormatVisitor	JsonFormatVisitorWrapper.expectNumberFormat(JavaType type)
JsonNumberFormatVisitor	JsonFormatVisitorWrapper.Base.expectNumberFormat(JavaType type)
JsonObjectFormatVisitor	JsonFormatVisitorWrapper.expectObjectFormat(JavaType type)
JsonObjectFormatVisitor	JsonFormatVisitorWrapper.Base.expectObjectFormat(JavaType type)
JsonStringFormatVisitor	JsonFormatVisitorWrapper.expectStringFormat(JavaType type)
JsonStringFormatVisitor	JsonFormatVisitorWrapper.Base.expectStringFormat(JavaType type)
void	JsonArrayFormatVisitor.itemsFormat(JsonFormatVisitable handler, JavaType elementType) Visit method called for structured types, as well as possibly for leaf types (especially if handled by custom serializers).
void	JsonArrayFormatVisitor.Base.itemsFormat(JsonFormatVisitable handler, JavaType elementType)
void	JsonMapFormatVisitor.keyFormat(JsonFormatVisitable handler, JavaType keyType) Visit method called to indicate type of keys of the Map type being visited
void	JsonMapFormatVisitor.Base.keyFormat(JsonFormatVisitable handler, JavaType keyType)
void	JsonObjectFormatVisitor.optionalProperty(String name, JsonFormatVisitable handler, JavaType propertyTypeHint)
void	JsonObjectFormatVisitor.Base.optionalProperty(String name, JsonFormatVisitable handler, JavaType propertyTypeHint)
void	JsonObjectFormatVisitor.property(String name, JsonFormatVisitable handler, JavaType propertyTypeHint) Callback method called when a non-POJO property (typically something like an Enum entry of EnumMap type) is being traversed.
void	JsonObjectFormatVisitor.Base.property(String name, JsonFormatVisitable handler, JavaType propertyTypeHint)
void	JsonMapFormatVisitor.valueFormat(JsonFormatVisitable handler, JavaType valueType) Visit method called after JsonMapFormatVisitor.keyFormat(com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitable, com.fasterxml.jackson.databind.JavaType) to allow visiting of the value type
void	JsonMapFormatVisitor.Base.valueFormat(JsonFormatVisitable handler, JavaType valueType)

Uses of JavaType in com.fasterxml.jackson.databind.jsontype

Methods in com.fasterxml.jackson.databind.jsontype that return JavaType

Modifier and Type	Method and Description
JavaType	TypeIdResolver.typeFromId(DatabindContext context, String id) Method called to resolve type from given type identifier.

Methods in com.fasterxml.jackson.databind.jsontype with parameters of type JavaType

Modifier and Type	Method and Description
TypeDeserializer	TypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) Method for building type deserializer based on current configuration of this builder.
TypeSerializer	TypeResolverBuilder.buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes) Method for building type serializer based on current configuration of this builder.
Collection<NamedType>	SubtypeResolver.collectAndResolveSubtypes(AnnotatedMember property, MapperConfig<?> config, AnnotationIntrospector ai, JavaType baseType) Deprecated. Since 2.6 Use either SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig, AnnotatedMember, JavaType) or SubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig, AnnotatedMember, JavaType) instead.
Collection<NamedType>	SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedMember property, JavaType baseType) Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type, typically needed for serialization (converting from type to type name).
Collection<NamedType>	SubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedMember property, JavaType baseType) Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type id, typically needed for deserialization (converting from type id to type).
static Object	TypeDeserializer.deserializeIfNatural(JsonParser p, DeserializationContext ctxt, JavaType baseType) Helper method used to check if given parser might be pointing to a "natural" value, and one that would be acceptable as the result value (compatible with declared base type)
void	TypeIdResolver.init(JavaType baseType) Method that will be called once before any type resolution calls; used to initialize instance with configuration.

Uses of JavaType in com.fasterxml.jackson.databind.jsontype.impl

Fields in com.fasterxml.jackson.databind.jsontype.impl declared as JavaType

Modifier and Type	Field and Description
protected JavaType	TypeIdResolverBase._baseType Common base type for all polymorphic instances handled.
protected JavaType	TypeDeserializerBase._baseType
protected JavaType	TypeDeserializerBase._defaultImpl Type to use as the default implementation, if type id is missing or cannot be resolved.

Fields in com.fasterxml.jackson.databind.jsontype.impl with type parameters of type JavaType

Modifier and Type	Field and Description
protected Map<String,JavaType>	TypeNameIdResolver._idToType Mappings from type id to JavaType, used for deserialization

Methods in com.fasterxml.jackson.databind.jsontype.impl that return JavaType

Modifier and Type	Method and Description
protected JavaType	TypeDeserializerBase._handleMissingTypeId(DeserializationContext ctxt, String extraDesc)
protected JavaType	TypeDeserializerBase._handleUnknownTypeId(DeserializationContext ctxt, String typeId) Helper method called when given type id cannot be resolved into concrete deserializer either directly (using given TypeIdResolver), or using default type.
protected JavaType	TypeNameIdResolver._typeFromId(String id)
protected JavaType	MinimalClassNameIdResolver._typeFromId(String id, DatabindContext ctxt)
protected JavaType	ClassNameIdResolver._typeFromId(String id, DatabindContext ctxt)
JavaType	TypeDeserializerBase.baseType()
JavaType	TypeNameIdResolver.typeFromId(DatabindContext context, String id)
JavaType	TypeIdResolverBase.typeFromId(DatabindContext context, String id)
JavaType	ClassNameIdResolver.typeFromId(DatabindContext context, String id)

Methods in com.fasterxml.jackson.databind.jsontype.impl with parameters of type JavaType

Modifier and Type	Method and Description
TypeDeserializer	StdTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes)
TypeSerializer	StdTypeResolverBuilder.buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)
static TypeNameIdResolver	TypeNameIdResolver.construct(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)
protected TypeIdResolver	StdTypeResolverBuilder.idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) Helper method that will either return configured custom type id resolver, or construct a standard resolver given configuration.
void	TypeIdResolverBase.init(JavaType bt)
void	SubTypeValidator.validateSubType(DeserializationContext ctxt, JavaType type, BeanDescription beanDesc)

Constructors in com.fasterxml.jackson.databind.jsontype.impl with parameters of type JavaType

Constructor and Description
AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl)
AsExternalTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl)
AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl)
AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl, JsonTypeInfo.As inclusion)
AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl)
ClassNameIdResolver(JavaType baseType, TypeFactory typeFactory)
MinimalClassNameIdResolver(JavaType baseType, TypeFactory typeFactory)
TypeDeserializerBase(JavaType baseType, TypeIdResolver idRes, String typePropertyName, boolean typeIdVisible, JavaType defaultImpl)
TypeIdResolverBase(JavaType baseType, TypeFactory typeFactory)
TypeNameIdResolver(MapperConfig<?> config, JavaType baseType, Map<String,String> typeToId, Map<String,JavaType> idToType)

Constructor parameters in com.fasterxml.jackson.databind.jsontype.impl with type arguments of type JavaType

Constructor and Description
TypeNameIdResolver(MapperConfig<?> config, JavaType baseType, Map<String,String> typeToId, Map<String,JavaType> idToType)

Uses of JavaType in com.fasterxml.jackson.databind.module

Methods in com.fasterxml.jackson.databind.module that return JavaType

Modifier and Type	Method and Description
JavaType	SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config, JavaType type)
JavaType	SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config, BeanDescription typeDesc)
JavaType	SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config, JavaType type) Deprecated.

Methods in com.fasterxml.jackson.databind.module with parameters of type JavaType

Modifier and Type	Method and Description
JsonDeserializer<?>	SimpleDeserializers.findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
KeyDeserializer	SimpleKeyDeserializers.findKeyDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc)
JsonSerializer<?>	SimpleSerializers.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)
JavaType	SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config, JavaType type)
JavaType	SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config, JavaType type) Deprecated.

Uses of JavaType in com.fasterxml.jackson.databind.ser

Fields in com.fasterxml.jackson.databind.ser declared as JavaType

Modifier and Type	Field and Description
protected JavaType	BeanPropertyWriter._cfgSerializationType Type to use for locating serializer; normally same as return type of the accessor method, but may be overridden by annotations.
protected JavaType	BeanPropertyWriter._declaredType Type property is declared to have, either in class definition or associated annotations.
protected JavaType	BeanPropertyWriter._nonTrivialBaseType Base type of the property, if the declared type is "non-trivial"; meaning it is either a structured type (collection, map, array), or parameterized.

Methods in com.fasterxml.jackson.databind.ser that return JavaType

Modifier and Type	Method and Description
protected JavaType	PropertyBuilder.findSerializationType(Annotated a, boolean useStaticTyping, JavaType declaredType) Method that will try to determine statically defined type of property being serialized, based on annotations (for overrides), and alternatively declared type (if static typing for serialization is enabled).
abstract JavaType	ContainerSerializer.getContentType() Accessor for finding declared (static) element type for type this serializer is used for.
JavaType	BeanPropertyWriter.getSerializationType()
JavaType	BeanPropertyWriter.getType()

Methods in com.fasterxml.jackson.databind.ser with parameters of type JavaType

Modifier and Type	Method and Description
protected JsonSerializer<?>	BeanSerializerFactory._createSerializer2(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping)
protected JsonInclude.Value	BasicSerializerFactory._findInclusionWithContent(SerializerProvider prov, BeanDescription beanDesc, JavaType contentType, Class<?> configType) Helper method used for finding inclusion definitions for structured container types like Maps and referential types (like AtomicReference).
void	DefaultSerializerProvider.acceptJsonFormatVisitor(JavaType javaType, JsonFormatVisitorWrapper visitor) The method to be called by ObjectMapper and ObjectWriter to to expose the format of the given to to the given visitor
void	SerializerCache.addAndResolveNonTypedSerializer(Class<?> rawType, JavaType fullType, JsonSerializer<Object> ser, SerializerProvider provider) Another alternative that will cover both access via raw type and matching fully resolved type, in one fell swoop.
void	SerializerCache.addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser, SerializerProvider provider)
void	SerializerCache.addTypedSerializer(JavaType type, JsonSerializer<Object> ser) Method called if none of lookups succeeded, and caller had to construct a serializer.
ContainerSerializer<?>	BasicSerializerFactory.buildCollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer)
protected JsonSerializer<?>	BasicSerializerFactory.buildContainerSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping)
protected JsonSerializer<?>	BasicSerializerFactory.buildEnumSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)
JsonSerializer<?>	BasicSerializerFactory.buildEnumSetSerializer(JavaType enumType)
ContainerSerializer<?>	BasicSerializerFactory.buildIndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer)
protected JsonSerializer<?>	BasicSerializerFactory.buildIterableSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping, JavaType valueType)
protected JsonSerializer<?>	BasicSerializerFactory.buildIteratorSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping, JavaType valueType)
protected JsonSerializer<?>	BasicSerializerFactory.buildMapEntrySerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping, JavaType keyType, JavaType valueType)
protected BeanPropertyWriter	PropertyBuilder.buildWriter(SerializerProvider prov, BeanPropertyDefinition propDef, JavaType declaredType, JsonSerializer<?> ser, TypeSerializer typeSer, TypeSerializer contentTypeSer, AnnotatedMember am, boolean defaultUseStaticTyping)
static BeanSerializer	BeanSerializer.createDummy(JavaType forType) Method for constructing dummy bean serializer; one that never outputs any properties
abstract JsonSerializer<Object>	SerializerFactory.createKeySerializer(SerializationConfig config, JavaType type, JsonSerializer<Object> defaultImpl) Method called to create serializer to use for serializing JSON property names (which must be output as JsonToken.FIELD_NAME) for Map that has specified declared key type, and is for specified property (or, if property is null, as root value)
JsonSerializer<Object>	BasicSerializerFactory.createKeySerializer(SerializationConfig config, JavaType keyType, JsonSerializer<Object> defaultImpl)
abstract JsonSerializer<Object>	SerializerFactory.createSerializer(SerializerProvider prov, JavaType baseType) Method called to create (or, for immutable serializers, reuse) a serializer for given type.
JsonSerializer<Object>	BeanSerializerFactory.createSerializer(SerializerProvider prov, JavaType origType) Main serializer constructor method.
abstract JsonSerializer<Object>	BasicSerializerFactory.createSerializer(SerializerProvider prov, JavaType type)
abstract TypeSerializer	SerializerFactory.createTypeSerializer(SerializationConfig config, JavaType baseType) Method called to create a type information serializer for given base type, if one is needed.
TypeSerializer	BasicSerializerFactory.createTypeSerializer(SerializationConfig config, JavaType baseType) Method called to construct a type serializer for values with given declared base type.
JsonSerializer<Object>	BeanSerializerFactory.findBeanSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc) Method that will try to construct a BeanSerializer for given class.
protected JsonSerializer<?>	BasicSerializerFactory.findOptionalStdSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping) Overridable method called after checking all other types.
TypeSerializer	BeanSerializerFactory.findPropertyContentTypeSerializer(JavaType containerType, SerializationConfig config, AnnotatedMember accessor) Method called to create a type information serializer for values of given container property if one is needed.
TypeSerializer	BeanSerializerFactory.findPropertyTypeSerializer(JavaType baseType, SerializationConfig config, AnnotatedMember accessor) Method called to create a type information serializer for values of given non-container property if one is needed.
protected JavaType	PropertyBuilder.findSerializationType(Annotated a, boolean useStaticTyping, JavaType declaredType) Method that will try to determine statically defined type of property being serialized, based on annotations (for overrides), and alternatively declared type (if static typing for serialization is enabled).
JsonSerializer<?>	Serializers.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc) Method called by serialization framework first time a serializer is needed for specified type, which is not of a container or reference type (for which other methods are called).
JsonSerializer<?>	Serializers.Base.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)
protected JsonSerializer<?>	BasicSerializerFactory.findSerializerByAddonType(SerializationConfig config, JavaType javaType, BeanDescription beanDesc, boolean staticTyping) Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces.
protected JsonSerializer<?>	BasicSerializerFactory.findSerializerByAnnotations(SerializerProvider prov, JavaType type, BeanDescription beanDesc) Method called to see if one of primary per-class annotations (or related, like implementing of JsonSerializable) determines the serializer to use.
protected JsonSerializer<?>	BasicSerializerFactory.findSerializerByLookup(JavaType type, SerializationConfig config, BeanDescription beanDesc, boolean staticTyping) Method that will use fast lookup (and identity comparison) methods to see if we know serializer to use for given type.
protected JsonSerializer<?>	BasicSerializerFactory.findSerializerByPrimaryType(SerializerProvider prov, JavaType type, BeanDescription beanDesc, boolean staticTyping) Method for checking if we can determine serializer to use based on set of known primary types, checking for set of known base types (exact matches having been compared against with findSerializerByLookup).
protected Object	PropertyBuilder.getDefaultValue(JavaType type) Deprecated. Since 2.9
protected Object	PropertyBuilder.getPropertyDefaultValue(String name, AnnotatedMember member, JavaType type) Deprecated. Since 2.9 since this will not allow determining difference between "no default instance" case and default being `null`.
JsonSerializer<?>	BeanSerializerModifier.modifyEnumSerializer(SerializationConfig config, JavaType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer)
JsonSerializer<?>	BeanSerializerModifier.modifyKeySerializer(SerializationConfig config, JavaType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) Method called by DeserializerFactory after it has constructed the default key serializer to use for serializing Map keys of given type.
void	DefaultSerializerProvider.serializePolymorphic(JsonGenerator gen, Object value, JavaType rootType, JsonSerializer<Object> valueSer, TypeSerializer typeSer) Alternate serialization call used for polymorphic types, when TypeSerializer is already known, but the actual serializer may or may not be.
void	DefaultSerializerProvider.serializeValue(JsonGenerator gen, Object value, JavaType rootType) The method to be called by ObjectMapper and ObjectWriter for serializing given value (assumed to be of specified root type, instead of runtime type of value), using serializers that this provider has access to (via caching and/or creating new serializers as need be),
void	DefaultSerializerProvider.serializeValue(JsonGenerator gen, Object value, JavaType rootType, JsonSerializer<Object> ser) The method to be called by ObjectWriter for serializing given value (assumed to be of specified root type, instead of runtime type of value), when it may know specific JsonSerializer to use.
void	BeanPropertyWriter.setNonTrivialBaseType(JavaType t) Method called to define type to consider as "non-trivial" basetype, needed for dynamic serialization resolution for complex (usually container) types
JsonSerializer<Object>	SerializerCache.typedValueSerializer(JavaType type)
JsonSerializer<Object>	SerializerCache.untypedValueSerializer(JavaType type)
abstract VirtualBeanPropertyWriter	VirtualBeanPropertyWriter.withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type) Contextualization method called on a newly constructed virtual bean property.

Constructors in com.fasterxml.jackson.databind.ser with parameters of type JavaType

Constructor and Description
BeanPropertyWriter(BeanPropertyDefinition propDef, AnnotatedMember member, Annotations contextAnnotations, JavaType declaredType, JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType, boolean suppressNulls, Object suppressableValue) Deprecated.
BeanPropertyWriter(BeanPropertyDefinition propDef, AnnotatedMember member, Annotations contextAnnotations, JavaType declaredType, JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType, boolean suppressNulls, Object suppressableValue, Class<?>[] includeInViews)
BeanSerializer(JavaType type, BeanSerializerBuilder builder, BeanPropertyWriter[] properties, BeanPropertyWriter[] filteredProperties)
ContainerSerializer(JavaType fullType)
VirtualBeanPropertyWriter(BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType) Constructor used by most sub-types.
VirtualBeanPropertyWriter(BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType, JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType, JsonInclude.Value inclusion) Deprecated.
VirtualBeanPropertyWriter(BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType, JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType, JsonInclude.Value inclusion, Class<?>[] includeInViews) Pass-through constructor that may be used by sub-classes that want full control over implementation.

Uses of JavaType in com.fasterxml.jackson.databind.ser.impl

Fields in com.fasterxml.jackson.databind.ser.impl declared as JavaType

Modifier and Type	Field and Description
protected JavaType	MapEntrySerializer._entryType
protected JavaType	MapEntrySerializer._keyType
protected JavaType	MapEntrySerializer._valueType
JavaType	ObjectIdWriter.idType

Methods in com.fasterxml.jackson.databind.ser.impl that return JavaType

Modifier and Type	Method and Description
JavaType	StringArraySerializer.getContentType()
JavaType	MapEntrySerializer.getContentType()

Methods in com.fasterxml.jackson.databind.ser.impl with parameters of type JavaType

Modifier and Type	Method and Description
protected JsonSerializer<Object>	MapEntrySerializer._findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider)
void	UnknownSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StringArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	FailingSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
PropertySerializerMap.SerializerAndMapResult	PropertySerializerMap.addSerializer(JavaType type, JsonSerializer<Object> serializer)
static ObjectIdWriter	ObjectIdWriter.construct(JavaType idType, PropertyName propName, ObjectIdGenerator<?> generator, boolean alwaysAsId) Factory method called by BeanSerializerBase with the initial information based on standard settings for the type for which serializer is being built.
static AttributePropertyWriter	AttributePropertyWriter.construct(String attrName, BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType)
PropertySerializerMap.SerializerAndMapResult	PropertySerializerMap.findAndAddPrimarySerializer(JavaType type, SerializerProvider provider, BeanProperty property)
PropertySerializerMap.SerializerAndMapResult	PropertySerializerMap.findAndAddRootValueSerializer(JavaType type, SerializerProvider provider)
PropertySerializerMap.SerializerAndMapResult	PropertySerializerMap.findAndAddSecondarySerializer(JavaType type, SerializerProvider provider, BeanProperty property)
JsonSerializer<Object>	ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type)
JsonSerializer<Object>	ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type)
VirtualBeanPropertyWriter	AttributePropertyWriter.withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type) Since this method should typically not be called on this sub-type, default implementation simply throws an IllegalStateException.

Constructors in com.fasterxml.jackson.databind.ser.impl with parameters of type JavaType

Constructor and Description
AttributePropertyWriter(String attrName, BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType)
AttributePropertyWriter(String attrName, BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType, JsonInclude.Value inclusion)
IndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer)
IteratorSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
MapEntrySerializer(JavaType type, JavaType keyType, JavaType valueType, boolean staticTyping, TypeSerializer vts, BeanProperty property)
ObjectIdWriter(JavaType t, SerializableString propName, ObjectIdGenerator<?> gen, JsonSerializer<?> ser, boolean alwaysAsId)

Uses of JavaType in com.fasterxml.jackson.databind.ser.std

Fields in com.fasterxml.jackson.databind.ser.std declared as JavaType

Modifier and Type	Field and Description
protected JavaType	BeanSerializerBase._beanType
protected JavaType	StdDelegatingSerializer._delegateType Fully resolved delegate type, with generic information if any available.
protected JavaType	ObjectArraySerializer._elementType Declared type of element entries
protected JavaType	AsArraySerializerBase._elementType
protected JavaType	MapSerializer._keyType Declared type of keys
protected JavaType	ReferenceTypeSerializer._referredType Value type
protected JavaType	MapSerializer._valueType Declared type of contained values
protected static JavaType	MapSerializer.UNSPECIFIED_TYPE

Methods in com.fasterxml.jackson.databind.ser.std that return JavaType

Modifier and Type	Method and Description
JavaType	StdArraySerializers.BooleanArraySerializer.getContentType()
JavaType	StdArraySerializers.ShortArraySerializer.getContentType()
JavaType	StdArraySerializers.IntArraySerializer.getContentType()
JavaType	StdArraySerializers.LongArraySerializer.getContentType()
JavaType	StdArraySerializers.FloatArraySerializer.getContentType()
JavaType	StdArraySerializers.DoubleArraySerializer.getContentType()
JavaType	ObjectArraySerializer.getContentType()
JavaType	MapSerializer.getContentType()
JavaType	AsArraySerializerBase.getContentType()
JavaType	ReferenceTypeSerializer.getReferredType()
JavaType	MapProperty.getType()

Methods in com.fasterxml.jackson.databind.ser.std with parameters of type JavaType

Modifier and Type	Method and Description
protected void	DateTimeSerializerBase._acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint, boolean asNumber)
protected boolean	JsonValueSerializer._acceptJsonFormatVisitorForEnum(JsonFormatVisitorWrapper visitor, JavaType typeHint, Class<?> enumType) Overridable helper method used for special case handling of schema information for Enums.
protected JsonSerializer<Object>	ObjectArraySerializer._findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider)
protected JsonSerializer<Object>	MapSerializer._findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider)
protected JsonSerializer<Object>	AsArraySerializerBase._findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider)
protected boolean	ReferenceTypeSerializer._useStatic(SerializerProvider provider, BeanProperty property, JavaType referredType)
void	TokenBufferSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ToStringSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StringSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) Default implementation specifies no format.
void	StdScalarSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdKeySerializers.Dynamic.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdJdkSerializers.AtomicBooleanSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdJdkSerializers.AtomicIntegerSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdJdkSerializers.AtomicLongSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdDelegatingSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.BooleanArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.ShortArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.CharArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.IntArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.LongArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.FloatArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StdArraySerializers.DoubleArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	StaticListSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	SqlTimeSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	SerializableSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ReferenceTypeSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	RawSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ObjectArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	NumberSerializers.Base.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	NumberSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	NullSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	MapSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	JsonValueSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	FileSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	EnumSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	DateTimeSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ClassSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ByteBufferSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	ByteArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	BooleanSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	BeanSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	AsArraySerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
static MapSerializer	MapSerializer.construct(Set<String> ignoredEntries, JavaType mapType, boolean staticValueType, TypeSerializer vts, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer, Object filterId)
static MapSerializer	MapSerializer.construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer, Object filterId) Deprecated. Since 2.8 use the other overload
protected void	StdSerializer.visitArrayFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonFormatTypes itemType)
protected void	StdSerializer.visitArrayFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonSerializer<?> itemSerializer, JavaType itemType)
protected void	StdSerializer.visitFloatFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonParser.NumberType numberType) Helper method that calls necessary visit method(s) to indicate that the underlying JSON type is a floating-point JSON number.
protected void	StdSerializer.visitIntFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonParser.NumberType numberType) Helper method that calls necessary visit method(s) to indicate that the underlying JSON type is JSON Integer number.
protected void	StdSerializer.visitIntFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonParser.NumberType numberType, JsonValueFormat format) Helper method that calls necessary visit method(s) to indicate that the underlying JSON type is JSON Integer number, but that there is also a further format restriction involved.
protected void	StdSerializer.visitStringFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint) Helper method that calls necessary visit method(s) to indicate that the underlying JSON type is JSON String.
protected void	StdSerializer.visitStringFormat(JsonFormatVisitorWrapper visitor, JavaType typeHint, JsonValueFormat format) Helper method that calls necessary visit method(s) to indicate that the underlying JSON type is JSON String, but that there is a more refined logical type
protected StdDelegatingSerializer	StdDelegatingSerializer.withDelegate(Converter<Object,?> converter, JavaType delegateType, JsonSerializer<?> delegateSerializer) Method used for creating resolved contextual instances.

Constructors in com.fasterxml.jackson.databind.ser.std with parameters of type JavaType

Constructor and Description
AsArraySerializerBase(Class<?> cls, JavaType et, boolean staticTyping, TypeSerializer vts, BeanProperty property, JsonSerializer<Object> elementSerializer) Deprecated. Since 2.6 Use variants that either take 'src', or do NOT pass BeanProperty
AsArraySerializerBase(Class<?> cls, JavaType et, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> elementSerializer) Non-contextual, "blueprint" constructor typically called when the first instance is created, without knowledge of property it was used via.
BeanSerializerBase(JavaType type, BeanSerializerBuilder builder, BeanPropertyWriter[] properties, BeanPropertyWriter[] filteredProperties) Constructor used by BeanSerializerBuilder to create an instance
CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, BeanProperty property, JsonSerializer<Object> valueSerializer) Deprecated. since 2.6
CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer)
EnumSetSerializer(JavaType elemType)
IterableSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts)
MapSerializer(Set<String> ignoredEntries, JavaType keyType, JavaType valueType, boolean valueTypeIsStatic, TypeSerializer vts, JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer)
ObjectArraySerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> elementSerializer)
StdDelegatingSerializer(Converter<Object,?> converter, JavaType delegateType, JsonSerializer<?> delegateSerializer)
StdSerializer(JavaType type)

Uses of JavaType in com.fasterxml.jackson.databind.type

Subclasses of JavaType in com.fasterxml.jackson.databind.type

Modifier and Type	Class and Description
class	ArrayType Array types represent Java arrays, both primitive and object valued.
class	CollectionLikeType Type that represents things that act similar to Collection; but may or may not be instances of that interface.
class	CollectionType Type that represents Java Collection types (Lists, Sets).
class	MapLikeType Type that represents Map-like types; things that consist of key/value pairs but that do not necessarily implement Map, but that do not have enough introspection functionality to allow for some level of generic handling.
class	MapType Type that represents "true" Java Map types.
class	PlaceholderForType Helper type used when introspecting bindings for already resolved types, needed for specialization.
class	ReferenceType Specialized SimpleType for types that are referential types, that is, values that can be dereferenced to another value (or null), of different type.
class	ResolvedRecursiveType Internal placeholder type used for self-references.
class	SimpleType Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps).
class	TypeBase

Fields in com.fasterxml.jackson.databind.type declared as JavaType

Modifier and Type	Field and Description
protected JavaType	PlaceholderForType._actualType Type assigned during wildcard resolution (which follows type structure resolution)
protected JavaType	ReferenceType._anchorType Essential type used for type ids, for example if type id is needed for referencing type with polymorphic handling.
protected JavaType	ArrayType._componentType Type of elements in the array.
protected JavaType	CollectionLikeType._elementType Type of elements in collection
protected JavaType	MapLikeType._keyType Type of keys of Map.
protected JavaType	ResolvedRecursiveType._referencedType
protected JavaType	ReferenceType._referencedType
protected JavaType	TypeBase._superClass
protected JavaType[]	TypeBase._superInterfaces
protected JavaType	MapLikeType._valueType Type of values of Map.

Fields in com.fasterxml.jackson.databind.type with type parameters of type JavaType

Modifier and Type	Field and Description
protected LRUMap<Object,JavaType>	TypeFactory._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

Methods in com.fasterxml.jackson.databind.type that return JavaType

Modifier and Type	Method and Description
protected static JavaType	TypeBase._bogusSuperClass(Class<?> cls) Internal helper method used to figure out nominal super-class for deprecated factory methods / constructors, where we are not given properly resolved supertype hierarchy.
protected JavaType	TypeFactory._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 JavaType	TypeFactory._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	TypeFactory._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	TypeFactory._fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)
protected JavaType	TypeFactory._fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)
protected JavaType	TypeFactory._fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings) This method deals with parameterized types, that is, first class generic classes.
protected JavaType	TypeFactory._fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)
protected JavaType	TypeFactory._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	TypeFactory._fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType	TypeFactory._fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)
protected JavaType	SimpleType._narrow(Class<?> subclass) Deprecated.
protected JavaType	ResolvedRecursiveType._narrow(Class<?> subclass) Deprecated.
protected JavaType	ReferenceType._narrow(Class<?> subclass) Deprecated.
protected JavaType	PlaceholderForType._narrow(Class<?> subclass)
protected JavaType	MapType._narrow(Class<?> subclass) Deprecated.
protected JavaType	MapLikeType._narrow(Class<?> subclass) Deprecated.
protected JavaType	CollectionType._narrow(Class<?> subclass) Deprecated.
protected JavaType	CollectionLikeType._narrow(Class<?> subclass) Deprecated.
protected JavaType	ArrayType._narrow(Class<?> subclass) Deprecated.
protected JavaType	TypeFactory._newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method that is to create a new SimpleType with no checks whatsoever.
protected JavaType	TypeFactory._resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType[]	TypeFactory._resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings)
protected JavaType	TypeFactory._unknownType()
JavaType	PlaceholderForType.actualType()
JavaType	TypeFactory.constructFromCanonical(String canonical) Factory method for constructing a JavaType out of its canonical representation (see ResolvedType.toCanonical()).
JavaType	TypeFactory.constructGeneralizedType(JavaType baseType, Class<?> superClass) Method similar to TypeFactory.constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>), but that creates a less-specific type of given type.
JavaType	TypeFactory.constructParametricType(Class<?> parametrized, Class<?>... parameterClasses) Factory method for constructing JavaType that represents a parameterized type.
JavaType	TypeFactory.constructParametricType(Class<?> rawType, JavaType... parameterTypes) Factory method for constructing JavaType that represents a parameterized type.
JavaType	TypeFactory.constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses) Deprecated. since 2.9 Use TypeFactory.constructParametricType(Class,Class...) instead
JavaType	TypeFactory.constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes) Deprecated. since 2.9 Use TypeFactory.constructParametricType(Class,JavaType...) instead
JavaType	TypeFactory.constructReferenceType(Class<?> rawType, JavaType referredType)
JavaType	TypeFactory.constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes) Deprecated. Since 2.7
JavaType	TypeFactory.constructSimpleType(Class<?> rawType, JavaType[] parameterTypes) Method for constructing a type instance with specified parameterization.
JavaType	TypeFactory.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	TypeFactory.constructType(Type type)
JavaType	TypeFactory.constructType(Type type, Class<?> contextClass) Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
JavaType	TypeFactory.constructType(Type type, JavaType contextType) Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
JavaType	TypeFactory.constructType(TypeReference<?> typeRef)
JavaType	TypeFactory.constructType(Type type, TypeBindings bindings)
JavaType	TypeBase.containedType(int index)
JavaType	TypeBindings.findBoundType(String name) Find type bound to specified name, if there is one; returns bound type if so, null if not.
JavaType	TypeBase.findSuperType(Class<?> rawTarget)
JavaType[]	TypeBase.findTypeParameters(Class<?> expType)
JavaType[]	TypeFactory.findTypeParameters(Class<?> clz, Class<?> expType) Deprecated. Since 2.7 resolve raw type first, then find type parameters
JavaType[]	TypeFactory.findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings) Deprecated. Since 2.7 resolve raw type first, then find type parameters
JavaType[]	TypeFactory.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.
JavaType	ReferenceType.getAnchorType()
JavaType	TypeBindings.getBoundType(int index)
JavaType	ReferenceType.getContentType()
JavaType	MapLikeType.getContentType()
JavaType	CollectionLikeType.getContentType()
JavaType	ArrayType.getContentType()
JavaType	MapLikeType.getKeyType()
JavaType	ReferenceType.getReferencedType()
JavaType	ResolvedRecursiveType.getSelfReferencedType()
JavaType	TypeBase.getSuperClass()
JavaType	ResolvedRecursiveType.getSuperClass()
abstract JavaType	TypeModifier.modifyType(JavaType type, Type jdkType, TypeBindings context, TypeFactory typeFactory) Method called to let modifier change constructed type definition.
JavaType	TypeFactory.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.
JavaType	TypeParser.parse(String canonical)
protected JavaType	TypeParser.parseType(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer tokens)
JavaType	SimpleType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ResolvedRecursiveType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ReferenceType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	PlaceholderForType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ArrayType.refine(Class<?> contentClass, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType[]	TypeBindings.typeParameterArray()
JavaType	TypeFactory.uncheckedSimpleType(Class<?> cls) Deprecated. Since 2.8, to indicate users should never call this method.
static JavaType	TypeFactory.unknownType() Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for java.lang.Object.
JavaType	SimpleType.withContentType(JavaType contentType)
JavaType	ResolvedRecursiveType.withContentType(JavaType contentType)
JavaType	ReferenceType.withContentType(JavaType contentType)
JavaType	PlaceholderForType.withContentType(JavaType contentType)
JavaType	MapType.withContentType(JavaType contentType)
JavaType	MapLikeType.withContentType(JavaType contentType)
JavaType	CollectionType.withContentType(JavaType contentType)
JavaType	CollectionLikeType.withContentType(JavaType contentType)
JavaType	ArrayType.withContentType(JavaType contentType)
JavaType	SimpleType.withContentTypeHandler(Object h)
JavaType	ResolvedRecursiveType.withContentTypeHandler(Object h)
JavaType	PlaceholderForType.withContentTypeHandler(Object h)
JavaType	ResolvedRecursiveType.withContentValueHandler(Object h)
JavaType	PlaceholderForType.withContentValueHandler(Object h)
JavaType	MapLikeType.withHandlersFrom(JavaType src)
JavaType	CollectionLikeType.withHandlersFrom(JavaType src)
JavaType	ResolvedRecursiveType.withStaticTyping()
JavaType	PlaceholderForType.withStaticTyping()
JavaType	ResolvedRecursiveType.withTypeHandler(Object h)
JavaType	PlaceholderForType.withTypeHandler(Object h)
JavaType	ResolvedRecursiveType.withValueHandler(Object h)
JavaType	PlaceholderForType.withValueHandler(Object h)

Methods in com.fasterxml.jackson.databind.type that return types with arguments of type JavaType

Modifier and Type	Method and Description
List<JavaType>	TypeBase.getInterfaces()
List<JavaType>	TypeBindings.getTypeParameters() Accessor for getting bound types in declaration order
protected List<JavaType>	TypeParser.parseTypes(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer tokens)

Methods in com.fasterxml.jackson.databind.type with parameters of type JavaType

Modifier and Type	Method and Description
protected JavaType	TypeFactory._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 JavaType	TypeFactory._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 JavaType	TypeFactory._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	TypeFactory._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	TypeFactory._fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType	TypeFactory._fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
protected JavaType	TypeFactory._newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method that is to create a new SimpleType with no checks whatsoever.
protected JavaType	TypeFactory._newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) Factory method that is to create a new SimpleType with no checks whatsoever.
void	PlaceholderForType.actualType(JavaType t)
static ReferenceType	ReferenceType.construct(Class<?> cls, JavaType refType) Deprecated.
static CollectionType	CollectionType.construct(Class<?> rawType, JavaType elemT) Deprecated. Since 2.7, remove from 2.9
static CollectionLikeType	CollectionLikeType.construct(Class<?> rawType, JavaType elemT) Deprecated. Since 2.7, use CollectionLikeType.upgradeFrom(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JavaType) for constructing instances, given pre-resolved SimpleType.
static MapType	MapType.construct(Class<?> rawType, JavaType keyT, JavaType valueT) Deprecated.
static MapLikeType	MapLikeType.construct(Class<?> rawType, JavaType keyT, JavaType valueT) Deprecated.
static ReferenceType	ReferenceType.construct(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType refType)
static ReferenceType	ReferenceType.construct(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType refType)
static CollectionType	CollectionType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT)
static CollectionType	CollectionType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT)
static CollectionLikeType	CollectionLikeType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT)
static CollectionLikeType	CollectionLikeType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT)
static MapType	MapType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType keyT, JavaType valueT)
static MapType	MapType.construct(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType keyT, JavaType valueT)
static ArrayType	ArrayType.construct(JavaType componentType, TypeBindings bindings)
static ArrayType	ArrayType.construct(JavaType componentType, TypeBindings bindings, Object valueHandler, Object typeHandler)
ArrayType	TypeFactory.constructArrayType(JavaType elementType) Method for constructing an ArrayType.
CollectionLikeType	TypeFactory.constructCollectionLikeType(Class<?> collectionClass, JavaType elementType) Method for constructing a CollectionLikeType.
CollectionType	TypeFactory.constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType) Method for constructing a CollectionType.
JavaType	TypeFactory.constructGeneralizedType(JavaType baseType, Class<?> superClass) Method similar to TypeFactory.constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>), but that creates a less-specific type of given type.
MapLikeType	TypeFactory.constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType) Method for constructing a MapLikeType instance
MapType	TypeFactory.constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType) Method for constructing a MapType instance
JavaType	TypeFactory.constructParametricType(Class<?> rawType, JavaType... parameterTypes) Factory method for constructing JavaType that represents a parameterized type.
JavaType	TypeFactory.constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes) Deprecated. since 2.9 Use TypeFactory.constructParametricType(Class,JavaType...) instead
JavaType	TypeFactory.constructReferenceType(Class<?> rawType, JavaType referredType)
JavaType	TypeFactory.constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes) Deprecated. Since 2.7
JavaType	TypeFactory.constructSimpleType(Class<?> rawType, JavaType[] parameterTypes) Method for constructing a type instance with specified parameterization.
JavaType	TypeFactory.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	TypeFactory.constructType(Type type, JavaType contextType) Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
static TypeBindings	TypeBindings.create(Class<?> erasedType, JavaType typeArg1)
static TypeBindings	TypeBindings.create(Class<?> erasedType, JavaType[] types)
static TypeBindings	TypeBindings.create(Class<?> erasedType, JavaType typeArg1, JavaType typeArg2)
static TypeBindings	TypeBindings.createIfNeeded(Class<?> erasedType, JavaType typeArg1) Alternate factory method that may be called if it is possible that type does or does not require type parameters; this is mostly useful for collection- and map-like types.
static TypeBindings	TypeBindings.createIfNeeded(Class<?> erasedType, JavaType[] types) Alternate factory method that may be called if it is possible that type does or does not require type parameters; this is mostly useful for collection- and map-like types.
JavaType[]	TypeFactory.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.
abstract JavaType	TypeModifier.modifyType(JavaType type, Type jdkType, TypeBindings context, TypeFactory typeFactory) Method called to let modifier change constructed type definition.
JavaType	TypeFactory.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.
JavaType	SimpleType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	SimpleType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ResolvedRecursiveType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ResolvedRecursiveType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ReferenceType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ReferenceType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	PlaceholderForType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	PlaceholderForType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	MapLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	CollectionLikeType.refine(Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ArrayType.refine(Class<?> contentClass, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
JavaType	ArrayType.refine(Class<?> contentClass, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)
void	ClassStack.resolveSelfReferences(JavaType resolved) Method called when type that this stack frame represents is fully resolved, allowing self-references to be completed (if there are any)
void	ResolvedRecursiveType.setReference(JavaType ref)
static ReferenceType	ReferenceType.upgradeFrom(JavaType baseType, JavaType refdType) Factory method that can be used to "upgrade" a basic type into collection-like one; usually done via TypeModifier
static CollectionLikeType	CollectionLikeType.upgradeFrom(JavaType baseType, JavaType elementType) Factory method that can be used to "upgrade" a basic type into collection-like one; usually done via TypeModifier
static MapLikeType	MapLikeType.upgradeFrom(JavaType baseType, JavaType keyT, JavaType valueT) Factory method that can be used to "upgrade" a basic type into collection-like one; usually done via TypeModifier
JavaType	SimpleType.withContentType(JavaType contentType)
JavaType	ResolvedRecursiveType.withContentType(JavaType contentType)
JavaType	ReferenceType.withContentType(JavaType contentType)
JavaType	PlaceholderForType.withContentType(JavaType contentType)
JavaType	MapType.withContentType(JavaType contentType)
JavaType	MapLikeType.withContentType(JavaType contentType)
JavaType	CollectionType.withContentType(JavaType contentType)
JavaType	CollectionLikeType.withContentType(JavaType contentType)
JavaType	ArrayType.withContentType(JavaType contentType)
JavaType	MapLikeType.withHandlersFrom(JavaType src)
JavaType	CollectionLikeType.withHandlersFrom(JavaType src)
MapType	MapType.withKeyType(JavaType keyType)
MapLikeType	MapLikeType.withKeyType(JavaType keyType)

Method parameters in com.fasterxml.jackson.databind.type with type arguments of type JavaType

Modifier and Type	Method and Description
static TypeBindings	TypeBindings.create(Class<?> erasedType, List<JavaType> typeList) Factory method for constructing bindings for given class using specified type parameters.
TypeFactory	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.

Constructors in com.fasterxml.jackson.databind.type with parameters of type JavaType

Constructor and Description
ArrayType(JavaType componentType, TypeBindings bindings, Object emptyInstance, Object valueHandler, Object typeHandler, boolean asStatic)
CollectionLikeType(Class<?> collT, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT, Object valueHandler, Object typeHandler, boolean asStatic)
CollectionLikeType(Class<?> collT, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType elemT, Object valueHandler, Object typeHandler, boolean asStatic)
CollectionLikeType(TypeBase base, JavaType elemT)
CollectionType(TypeBase base, JavaType elemT)
MapLikeType(Class<?> mapType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType keyT, JavaType valueT, Object valueHandler, Object typeHandler, boolean asStatic)
MapLikeType(Class<?> mapType, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType keyT, JavaType valueT, Object valueHandler, Object typeHandler, boolean asStatic)
MapLikeType(TypeBase base, JavaType keyT, JavaType valueT)
MapType(TypeBase base, JavaType keyT, JavaType valueT)
ReferenceType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType refType, JavaType anchorType, Object valueHandler, Object typeHandler, boolean asStatic)
ReferenceType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, JavaType refType, JavaType anchorType, Object valueHandler, Object typeHandler, boolean asStatic)
ReferenceType(TypeBase base, JavaType refType) Constructor used when upgrading into this type (via ReferenceType.upgradeFrom(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JavaType), the usual way for ReferenceTypes to come into existence.
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts)
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts)
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, int extraHash, Object valueHandler, Object typeHandler, boolean asStatic) Pass-through constructor used by ReferenceType.
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, int extraHash, Object valueHandler, Object typeHandler, boolean asStatic) Pass-through constructor used by ReferenceType.
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, Object valueHandler, Object typeHandler, boolean asStatic)
SimpleType(Class<?> cls, TypeBindings bindings, JavaType superClass, JavaType[] superInts, Object valueHandler, Object typeHandler, boolean asStatic)
TypeBase(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInts, int hash, Object valueHandler, Object typeHandler, boolean asStatic) Main constructor to use by extending classes.
TypeBase(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInts, int hash, Object valueHandler, Object typeHandler, boolean asStatic) Main constructor to use by extending classes.

Constructor parameters in com.fasterxml.jackson.databind.type with type arguments of type JavaType

Constructor and Description
TypeFactory(LRUMap<Object,JavaType> typeCache)
TypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)

Uses of JavaType in com.fasterxml.jackson.databind.util

Fields in com.fasterxml.jackson.databind.util declared as JavaType

Modifier and Type	Field and Description
protected JavaType	JSONWrappedObject._serializationType Optional static type to use for serialization; if null, runtime type is used.
protected JavaType	JSONPObject._serializationType Optional static type to use for serialization; if null, runtime type is used.
protected JavaType	TypeKey._type

Methods in com.fasterxml.jackson.databind.util that return JavaType

Modifier and Type	Method and Description
protected JavaType	StdConverter._findConverterType(TypeFactory tf)
JavaType	StdConverter.getInputType(TypeFactory typeFactory)
JavaType	Converter.getInputType(TypeFactory typeFactory) Method that can be used to find out actual input (source) type; this usually can be determined from type parameters, but may need to be implemented differently from programmatically defined converters (which cannot change static type parameter bindings).
JavaType	StdConverter.getOutputType(TypeFactory typeFactory)
JavaType	Converter.getOutputType(TypeFactory typeFactory) Method that can be used to find out actual output (target) type; this usually can be determined from type parameters, but may need to be implemented differently from programmatically defined converters (which cannot change static type parameter bindings).
JavaType	SimpleBeanPropertyDefinition.getPrimaryType()
JavaType	JSONWrappedObject.getSerializationType()
JavaType	JSONPObject.getSerializationType()
JavaType	TypeKey.getType()

Methods in com.fasterxml.jackson.databind.util that return types with arguments of type JavaType

Modifier and Type	Method and Description
static List<JavaType>	ClassUtil.findSuperTypes(JavaType type, Class<?> endBefore, boolean addClassItself) Method that will find all sub-classes and implemented interfaces of a given class or interface.

Methods in com.fasterxml.jackson.databind.util with parameters of type JavaType

Modifier and Type	Method and Description
PropertyName	RootNameLookup.findRootName(JavaType rootType, MapperConfig<?> config)
static List<JavaType>	ClassUtil.findSuperTypes(JavaType type, Class<?> endBefore, boolean addClassItself) Method that will find all sub-classes and implemented interfaces of a given class or interface.
static Object	BeanUtil.getDefaultValue(JavaType type) Accessor used to find out "default value" to use for comparing values to serialize, to determine whether to exclude value from serialization with inclusion type of JsonInclude.Include.NON_DEFAULT.
static Class<?>	ClassUtil.rawClass(JavaType t)
void	TypeKey.resetTyped(JavaType type)
void	TypeKey.resetUntyped(JavaType type)
static int	TypeKey.typedHash(JavaType type)
static int	TypeKey.untypedHash(JavaType type)

Constructors in com.fasterxml.jackson.databind.util with parameters of type JavaType

Constructor and Description
JSONPObject(String function, Object value, JavaType asType)
JSONWrappedObject(String prefix, String suffix, Object value, JavaType asType) Constructor that should be used when specific serialization type to use is important, and needs to be passed instead of just using runtime (type-erased) type of the value.
TypeKey(JavaType key, boolean typed)

Uses of JavaType in com.fasterxml.jackson.datatype.jdk8

Methods in com.fasterxml.jackson.datatype.jdk8 that return JavaType

Modifier and Type	Method and Description
JavaType	Jdk8TypeModifier.modifyType(JavaType type, Type jdkType, TypeBindings bindings, TypeFactory typeFactory)

Methods in com.fasterxml.jackson.datatype.jdk8 with parameters of type JavaType

Modifier and Type	Method and Description
void	OptionalDoubleSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
JsonSerializer<?>	Jdk8Serializers.findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc)
JavaType	Jdk8TypeModifier.modifyType(JavaType type, Type jdkType, TypeBindings bindings, TypeFactory typeFactory)

Constructors in com.fasterxml.jackson.datatype.jdk8 with parameters of type JavaType

Constructor and Description
StreamSerializer(JavaType streamType, JavaType elemType) Constructor
StreamSerializer(JavaType streamType, JavaType elemType, JsonSerializer<Object> elemSerializer) Constructor with custom serializer

Uses of JavaType in com.fasterxml.jackson.datatype.jsr310.ser

Methods in com.fasterxml.jackson.datatype.jsr310.ser with parameters of type JavaType

Modifier and Type	Method and Description
protected void	YearSerializer._acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
protected void	YearMonthSerializer._acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
protected void	InstantSerializerBase._acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
protected void	DurationSerializer._acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	LocalDateSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)

Uses of JavaType in com.fasterxml.jackson.jaxrs.cfg

Methods in com.fasterxml.jackson.jaxrs.cfg with parameters of type JavaType

Modifier and Type	Method and Description
abstract ObjectReader	ObjectReaderModifier.modify(EndpointConfigBase<?> endpoint, MultivaluedMap<String,String> httpHeaders, JavaType resultType, ObjectReader r, JsonParser p) Method called to let modifier make any changes it wants to to objects used for reading request objects for specified endpoint.

Uses of JavaType in com.fasterxml.jackson.jaxrs.util

Methods in com.fasterxml.jackson.jaxrs.util with parameters of type JavaType

Modifier and Type	Method and Description
BeanProperty.Std	EndpointAsBeanProperty.withType(JavaType type)

Constructors in com.fasterxml.jackson.jaxrs.util with parameters of type JavaType

Constructor and Description
EndpointAsBeanProperty(EndpointAsBeanProperty base, JavaType newType)
EndpointAsBeanProperty(PropertyName name, JavaType type, Annotation[] annotations)

Uses of JavaType in com.fasterxml.jackson.module.jaxb

Fields in com.fasterxml.jackson.module.jaxb declared as JavaType

Modifier and Type	Field and Description
protected JavaType	AdapterConverter._inputType
protected JavaType	AdapterConverter._targetType

Methods in com.fasterxml.jackson.module.jaxb that return JavaType

Modifier and Type	Method and Description
protected JavaType	JaxbAnnotationIntrospector._fullDeserializationType(AnnotatedMember am)
protected JavaType	JaxbAnnotationIntrospector._fullSerializationType(AnnotatedMember am)
JavaType	AdapterConverter.getInputType(TypeFactory typeFactory)
JavaType	AdapterConverter.getOutputType(TypeFactory typeFactory)
JavaType	JaxbAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JaxbAnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)

Methods in com.fasterxml.jackson.module.jaxb with parameters of type JavaType

Modifier and Type	Method and Description
protected Class<?>	JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a, JavaType baseType)
TypeResolverBuilder<?>	JaxbAnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType containerType)
TypeResolverBuilder<?>	JaxbAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
TypeResolverBuilder<?>	JaxbAnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
JavaType	JaxbAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JaxbAnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)

Constructors in com.fasterxml.jackson.module.jaxb with parameters of type JavaType

Constructor and Description
AdapterConverter(XmlAdapter<?,?> adapter, JavaType inType, JavaType outType, boolean ser)

Uses of JavaType in com.fasterxml.jackson.module.jaxb.ser

Methods in com.fasterxml.jackson.module.jaxb.ser with parameters of type JavaType

Modifier and Type	Method and Description
void	DomElementJsonSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
void	DataHandlerJsonSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)