SimpleModule (jackson-databind 2.11.0.rc1 API)

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: 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 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

All Methods Instance Methods Concrete Methods
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)`
`<T> SimpleModule`	`addKeySerializer(Class<? extends T> type, JsonSerializer<T> ser)`
`<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
```
  - _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.
  - addSerializer
```
public <T> SimpleModule addSerializer(Class<? extends T> type,
                                      JsonSerializer<T> ser)
```
    Method for adding serializer to handle values of specific type.
    WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.
  - addKeySerializer
```
public <T> SimpleModule addKeySerializer(Class<? extends T> type,
                                         JsonSerializer<T> ser)
```
  - 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.
  - addKeyDeserializer
```
public SimpleModule addKeyDeserializer(Class<?> type,
                                       KeyDeserializer deser)
```
  - 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

Class SimpleModule

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

_name

_version

_serializers

_deserializers

_keySerializers

_keyDeserializers

_abstractTypes

_valueInstantiators

_deserializerModifier

_serializerModifier

_mixins

_subtypes

_namingStrategy

Constructor Detail

SimpleModule

SimpleModule

SimpleModule

SimpleModule

SimpleModule

SimpleModule

SimpleModule

Method Detail

getTypeId

setSerializers

setDeserializers

setKeySerializers

setKeyDeserializers

setAbstractTypes

setValueInstantiators

setDeserializerModifier

setSerializerModifier

setNamingStrategy

addSerializer

addSerializer

addKeySerializer

addDeserializer

addKeyDeserializer

addAbstractTypeMapping

registerSubtypes

registerSubtypes

registerSubtypes

addValueInstantiator

setMixInAnnotation

getModuleName

setupModule

version

_checkNotNull