com.fasterxml.jackson.databind.module

Class SimpleModule

java.lang.Object

com.fasterxml.jackson.databind.Module

com.fasterxml.jackson.databind.module.SimpleModule

All Implemented Interfaces:

Versioned, Serializable

public class SimpleModule
extends Module
implements Serializable

Vanilla Module implementation that allows registration of serializers and deserializers, bean serializer and deserializer modifiers, registration of subtypes and mix-ins as well as some other commonly needed aspects (addition of custom AbstractTypeResolvers, ValueInstantiators).

NOTE: that [de]serializers are registered as "default" [de]serializers. As a result, they will have lower priority than the ones indicated through annotations on both Class and property-associated annotations -- for example, JsonDeserialize.
In cases where both module-based [de]serializers and annotation-based [de]serializers are registered, the [de]serializer specified by the annotation will take precedence.

NOTE: although it is not expected that sub-types should need to override Module.setupModule(SetupContext) method, if they choose to do so they MUST call super.setupModule(context); to ensure that registration works as expected.

WARNING: when registering JsonSerializers and JsonDeserializers, only type erased Class is compared: this means that usually you should NOT use this implementation for registering structured types such as Collections or Maps: this because parametric type information will not be considered and you may end up having "wrong" handler for your type. What you need to do, instead, is to implement Deserializers and/or Serializers callbacks to match full type signatures (with JavaType).

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class com.fasterxml.jackson.databind.Module

Module.SetupContext

Field Summary

Fields

Modifier and Type	Field and Description
protected SimpleAbstractTypeResolver	_abstractTypes Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
protected BeanDeserializerModifier	_deserializerModifier
protected SimpleDeserializers	_deserializers
protected boolean	_hasExplicitName Flag that indicates whether module was given an explicit name or not.
protected SimpleKeyDeserializers	_keyDeserializers
protected SimpleSerializers	_keySerializers
protected HashMap<Class<?>,Class<?>>	_mixins Lazily-constructed map that contains mix-in definitions, indexed by target class, value being mix-in to apply.
protected String	_name
protected PropertyNamingStrategy	_namingStrategy
protected BeanSerializerModifier	_serializerModifier
protected SimpleSerializers	_serializers
protected LinkedHashSet<NamedType>	_subtypes Set of subtypes to register, if any.
protected SimpleValueInstantiators	_valueInstantiators Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
protected Version	_version

Constructor Summary

Constructors

Constructor and Description
SimpleModule() Constructors that should only be used for non-reusable convenience modules used by app code: "real" modules should use actual name and version number information.
SimpleModule(String name) Convenience constructor that will default version to Version.unknownVersion().
SimpleModule(String name, Version version) Constructor to use for actual reusable modules.
SimpleModule(String name, Version version, List<JsonSerializer<?>> serializers)
SimpleModule(String name, Version version, Map<Class<?>,JsonDeserializer<?>> deserializers)
SimpleModule(String name, Version version, Map<Class<?>,JsonDeserializer<?>> deserializers, List<JsonSerializer<?>> serializers)
SimpleModule(Version version) Convenience constructor that will use specified Version, including name from Version.getArtifactId().

Method Summary

Modifier and Type	Method and Description
protected void	_checkNotNull(Object thingy, String type)
<T> SimpleModule	addAbstractTypeMapping(Class<T> superType, Class<? extends T> subType) Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
<T> SimpleModule	addDeserializer(Class<T> type, JsonDeserializer<? extends T> deser) Method for adding deserializer to handle specified type.
SimpleModule	addKeyDeserializer(Class<?> type, KeyDeserializer deser) NOTE: This method registers "default" (de)serializers only.
<T> SimpleModule	addKeySerializer(Class<? extends T> type, JsonSerializer<T> ser) NOTE: This method registers "default" (de)serializers only.
<T> SimpleModule	addSerializer(Class<? extends T> type, JsonSerializer<T> ser) Method for adding serializer to handle values of specific type.
SimpleModule	addSerializer(JsonSerializer<?> ser) Method for adding serializer to handle type that the serializer claims to handle (see JsonSerializer.handledType()).
SimpleModule	addValueInstantiator(Class<?> beanType, ValueInstantiator inst) Method for registering ValueInstantiator to use when deserializing instances of type beanType.
String	getModuleName() Method that returns a display that can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.
Object	getTypeId() Since instances are likely to be custom, implementation returns null if (but only if!) this class is directly instantiated; but class name (default impl) for sub-classes.
SimpleModule	registerSubtypes(Class<?>... subtypes) Method for adding set of subtypes to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.
SimpleModule	registerSubtypes(Collection<Class<?>> subtypes) Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.
SimpleModule	registerSubtypes(NamedType... subtypes) Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.
void	setAbstractTypes(SimpleAbstractTypeResolver atr) Resets currently configured abstract type mappings
SimpleModule	setDeserializerModifier(BeanDeserializerModifier mod)
void	setDeserializers(SimpleDeserializers d) Resets all currently configured deserializers.
void	setKeyDeserializers(SimpleKeyDeserializers kd) Resets all currently configured key deserializers.
void	setKeySerializers(SimpleSerializers ks) Resets all currently configured key serializers.
SimpleModule	setMixInAnnotation(Class<?> targetType, Class<?> mixinClass) Method for specifying that annotations define by mixinClass should be "mixed in" with annotations that targetType has (as if they were directly included on it!).
protected SimpleModule	setNamingStrategy(PropertyNamingStrategy naming)
SimpleModule	setSerializerModifier(BeanSerializerModifier mod)
void	setSerializers(SimpleSerializers s) Resets all currently configured serializers.
void	setupModule(Module.SetupContext context) Standard implementation handles registration of all configured customizations: it is important that sub-classes call this implementation (usually before additional custom logic) if they choose to override it; otherwise customizations will not be registered.
void	setValueInstantiators(SimpleValueInstantiators svi) Resets all currently configured value instantiators
Version	version() Method that returns version of this module.

Methods inherited from class com.fasterxml.jackson.databind.Module

getDependencies

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

_name

protected final String _name

_version

protected final Version _version

_hasExplicitName

protected final boolean _hasExplicitName

Flag that indicates whether module was given an explicit name or not. Distinction is used to determine whether method getTypeId() should return name (yes, if explicit) or null (if no explicit name was passed).

Since:

2.13

_serializers

protected SimpleSerializers _serializers

_deserializers

protected SimpleDeserializers _deserializers

_keySerializers

protected SimpleSerializers _keySerializers

_keyDeserializers

protected SimpleKeyDeserializers _keyDeserializers

_abstractTypes

protected SimpleAbstractTypeResolver _abstractTypes

Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)

_valueInstantiators

protected SimpleValueInstantiators _valueInstantiators

Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)

_deserializerModifier

protected BeanDeserializerModifier _deserializerModifier

Since:

2.2

_serializerModifier

protected BeanSerializerModifier _serializerModifier

Since:

2.2

_mixins

protected HashMap<Class<?>,Class<?>> _mixins

Lazily-constructed map that contains mix-in definitions, indexed by target class, value being mix-in to apply.

_subtypes

protected LinkedHashSet<NamedType> _subtypes

Set of subtypes to register, if any.

_namingStrategy

protected PropertyNamingStrategy _namingStrategy

Since:

2.3

Constructor Detail

SimpleModule

public SimpleModule()

Constructors that should only be used for non-reusable convenience modules used by app code: "real" modules should use actual name and version number information.

SimpleModule

public SimpleModule(String name)

Convenience constructor that will default version to Version.unknownVersion().

SimpleModule

public SimpleModule(Version version)

Convenience constructor that will use specified Version, including name from Version.getArtifactId().

SimpleModule

public SimpleModule(String name,
                    Version version)

Constructor to use for actual reusable modules. ObjectMapper may use name as identifier to notice attempts for multiple registrations of the same module (although it does not have to).

Parameters:

name - Unique name of the module

version - Version of the module

SimpleModule

public SimpleModule(String name,
                    Version version,
                    Map<Class<?>,JsonDeserializer<?>> deserializers)

Since:

2.1

SimpleModule

public SimpleModule(String name,
                    Version version,
                    List<JsonSerializer<?>> serializers)

Since:

2.1

SimpleModule

public SimpleModule(String name,
                    Version version,
                    Map<Class<?>,JsonDeserializer<?>> deserializers,
                    List<JsonSerializer<?>> serializers)

Since:

2.1

Method Detail

getTypeId

public Object getTypeId()

Since instances are likely to be custom, implementation returns null if (but only if!) this class is directly instantiated; but class name (default impl) for sub-classes.

Overrides:

getTypeId in class Module

setSerializers

public void setSerializers(SimpleSerializers s)

Resets all currently configured serializers.

setDeserializers

public void setDeserializers(SimpleDeserializers d)

Resets all currently configured deserializers.

setKeySerializers

public void setKeySerializers(SimpleSerializers ks)

Resets all currently configured key serializers.

setKeyDeserializers

public void setKeyDeserializers(SimpleKeyDeserializers kd)

Resets all currently configured key deserializers.

setAbstractTypes

public void setAbstractTypes(SimpleAbstractTypeResolver atr)

Resets currently configured abstract type mappings

setValueInstantiators

public void setValueInstantiators(SimpleValueInstantiators svi)

Resets all currently configured value instantiators

setDeserializerModifier

public SimpleModule setDeserializerModifier(BeanDeserializerModifier mod)

Since:

2.2

setSerializerModifier

public SimpleModule setSerializerModifier(BeanSerializerModifier mod)

Since:

2.2

setNamingStrategy

protected SimpleModule setNamingStrategy(PropertyNamingStrategy naming)

Since:

2.3

addSerializer

public SimpleModule addSerializer(JsonSerializer<?> ser)

Method for adding serializer to handle type that the serializer claims to handle (see JsonSerializer.handledType()).

WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

addSerializer

public <T> SimpleModule addSerializer(Class<? extends T> type,
                                      JsonSerializer<T> ser)

Method for adding serializer to handle values of specific type.

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

addKeySerializer

public <T> SimpleModule addKeySerializer(Class<? extends T> type,
                                         JsonSerializer<T> ser)

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

addDeserializer

public <T> SimpleModule addDeserializer(Class<T> type,
                                        JsonDeserializer<? extends T> deser)

Method for adding deserializer to handle specified type.

WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

addKeyDeserializer

public SimpleModule addKeyDeserializer(Class<?> type,
                                       KeyDeserializer deser)

NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

addAbstractTypeMapping

public <T> SimpleModule addAbstractTypeMapping(Class<T> superType,
                                               Class<? extends T> subType)

Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)

registerSubtypes

public SimpleModule registerSubtypes(Class<?>... subtypes)

Method for adding set of subtypes to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.

registerSubtypes

public SimpleModule registerSubtypes(NamedType... subtypes)

Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.

registerSubtypes

public SimpleModule registerSubtypes(Collection<Class<?>> subtypes)

Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.

Since:

2.9

addValueInstantiator

public SimpleModule addValueInstantiator(Class<?> beanType,
                                         ValueInstantiator inst)

Method for registering ValueInstantiator to use when deserializing instances of type beanType.

Instantiator is registered when module is registered for ObjectMapper.

setMixInAnnotation

public SimpleModule setMixInAnnotation(Class<?> targetType,
                                       Class<?> mixinClass)

Method for specifying that annotations define by mixinClass should be "mixed in" with annotations that targetType has (as if they were directly included on it!).

Mix-in annotations are registered when module is registered for ObjectMapper.

getModuleName

public String getModuleName()

Description copied from class: Module

Method that returns a display that can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.

Specified by:

getModuleName in class Module

setupModule

public void setupModule(Module.SetupContext context)

Standard implementation handles registration of all configured customizations: it is important that sub-classes call this implementation (usually before additional custom logic) if they choose to override it; otherwise customizations will not be registered.

Specified by:

setupModule in class Module

version

public Version version()

Description copied from class: Module

Method that returns version of this module. Can be used by Jackson for informational purposes.

Specified by:

version in interface Versioned

Specified by:

version in class Module

_checkNotNull

protected void _checkNotNull(Object thingy,
                             String type)

Since:

2.9