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 `AbstractTypeResolver`s, `ValueInstantiator`s).

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 `JsonSerializer`s and `JsonDeserializer`s, only type erased `Class` is compared: this means that usually you should NOT use this implementation for registering structured types such as `Collection`s or `Map`s: 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
`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
`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