## com.fasterxml.jackson.databind.ser
Class BasicSerializerFactory

    java.lang.Object
      com.fasterxml.jackson.databind.ser.SerializerFactory
          com.fasterxml.jackson.databind.ser.BasicSerializerFactory

Direct Known Subclasses:
  BeanSerializerFactory

    public abstract class BasicSerializerFactory

extends SerializerFactory

Factory class that can provide serializers for standard JDK classes, as well as custom classes that extend standard classes or implement one of "well-known" interfaces (such as `Collection`).

Since all the serializers are eagerly instantiated, and there is no additional introspection or customizability of these types, this factory is essentially stateless.

Field Summary
`protected static HashMap<String,JsonSerializer<?>>` `_concrete` Since these are all JDK classes, we shouldn't have to worry about ClassLoader used to load them.
`protected static HashMap<String,Class<? extends JsonSerializer<?>>>` `_concreteLazy` Actually it may not make much sense to eagerly instantiate all kinds of serializers: so this Map actually contains class references, not instances
`protected SerializerFactoryConfig` `_factoryConfig` Configuration settings for this factory; immutable instance (just like this factory), new version created via copy-constructor (fluent-style)
`protected OptionalHandlerFactory` `optionalHandlers` Helper object used to deal with serializers for optional JDK types (like ones omitted from GAE, Android)

Constructor Summary
`protected` `BasicSerializerFactory(SerializerFactoryConfig config)` We will provide default constructor to allow sub-classing, but make it protected so that no non-singleton instances of the class will be instantiated.

Method Summary
`protected JsonSerializer<Object>` `_findContentSerializer(SerializerProvider prov, Annotated a, BeanProperty property)`
`protected JsonSerializer<Object>` `_findKeySerializer(SerializerProvider prov, Annotated a, BeanProperty property)`
`protected Class<?>` `_verifyAsClass(Object src, String methodName, Class<?> noneClass)`
`protected JsonSerializer<?>` `buildArraySerializer(SerializationConfig config, ArrayType type, BeanDescription beanDesc, boolean staticTyping, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)` Helper method that handles configuration details when constructing serializers for `Object[]` (and subtypes, except for String).
`protected JsonSerializer<?>` `buildCollectionSerializer(SerializationConfig config, CollectionType type, BeanDescription beanDesc, BeanProperty property, boolean staticTyping, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)` Helper method that handles configuration details when constructing serializers for `List` types that support efficient by-index access
`protected JsonSerializer<?>` `buildContainerSerializer(SerializerProvider prov, JavaType type, BeanDescription beanDesc, BeanProperty property, boolean staticTyping)`
`protected JsonSerializer<?>` `buildIterableSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping)`
`protected JsonSerializer<?>` `buildIteratorSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping)`
`protected JsonSerializer<?>` `buildMapSerializer(SerializationConfig config, MapType type, BeanDescription beanDesc, boolean staticTyping, JsonSerializer<Object> keySerializer, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)` Helper method that handles configuration details when constructing serializers for `Map` types.
`JsonSerializer<Object>` `createKeySerializer(SerializationConfig config, JavaType type)` 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)
`abstract JsonSerializer<Object>` `createSerializer(SerializerProvider prov, JavaType type, BeanProperty property)` Method called to create (or, for immutable serializers, reuse) a serializer for given type.
`TypeSerializer` `createTypeSerializer(SerializationConfig config, JavaType baseType)` Method called to construct a type serializer for values with given declared base type.
`protected abstract Iterable<Serializers>` `customSerializers()`
`protected JsonSerializer<?>` `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<?>` `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<?>` `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<?>` `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 JsonSerializer<Object>` `findSerializerFromAnnotation(SerializerProvider prov, Annotated a)` Helper method called to check if a class or method has an annotation (@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using) that tells the class to use for serialization.
`JsonSerializer<?>` `getNullSerializer()`
`protected boolean` `isIndexedList(Class<?> cls)`

`protected static

`<T extends JavaType> T`

`

`modifySecondaryTypesByAnnotation(SerializationConfig config, Annotated a, T type)`

`protected

`<T extends JavaType> T`

`

`modifyTypeByAnnotation(SerializationConfig config, Annotated a, T type)`
Helper method used to encapsulate details of annotation-based type coercion

`protected boolean` `usesStaticTyping(SerializationConfig config, BeanDescription beanDesc, TypeSerializer typeSer, BeanProperty property)` Helper method to check whether global settings and/or class annotations for the bean class indicate that static typing (declared types) should be used for properties.
`SerializerFactory` `withAdditionalKeySerializers(Serializers additional)` Convenience method for creating a new factory instance with an additional key serializer provider.
`SerializerFactory` `withAdditionalSerializers(Serializers additional)` Convenience method for creating a new factory instance with an additional serializer provider.
`abstract SerializerFactory` `withConfig(SerializerFactoryConfig config)` Method used for creating a new instance of this factory, but with different configuration.
`SerializerFactory` `withSerializerModifier(BeanSerializerModifier modifier)` Convenience method for creating a new factory instance with additional bean serializer modifier.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### _concrete

    protected static final HashMap<String,JsonSerializer<?>> _concrete

  Since these are all JDK classes, we shouldn't have to worry about ClassLoader used to load them. Rather, we can just use the class name, and keep things simple and efficient.

### _concreteLazy

    protected static final HashMap<String,Class<? extends JsonSerializer<?>>> _concreteLazy

  Actually it may not make much sense to eagerly instantiate all kinds of serializers: so this Map actually contains class references, not instances

### _factoryConfig

    protected final SerializerFactoryConfig _factoryConfig

  Configuration settings for this factory; immutable instance (just like this factory), new version created via copy-constructor (fluent-style)

### optionalHandlers

    protected OptionalHandlerFactory optionalHandlers

  Helper object used to deal with serializers for optional JDK types (like ones omitted from GAE, Android)

Constructor Detail

### BasicSerializerFactory

    protected BasicSerializerFactory(SerializerFactoryConfig config)

  We will provide default constructor to allow sub-classing, but make it protected so that no non-singleton instances of the class will be instantiated.

Method Detail

### withConfig

    public abstract SerializerFactory withConfig(SerializerFactoryConfig config)

  Method used for creating a new instance of this factory, but with different configuration. Reason for specifying factory method (instead of plain constructor) is to allow proper sub-classing of factories.

  Note that custom sub-classes generally must override implementation of this method, as it usually requires instantiating a new instance of factory type. Check out javadocs for `BeanSerializerFactory` for more details.

### withAdditionalSerializers

    public final SerializerFactory withAdditionalSerializers(Serializers additional)

  Convenience method for creating a new factory instance with an additional serializer provider.

  Specified by:
    `withAdditionalSerializers` in class `SerializerFactory`

### withAdditionalKeySerializers

    public final SerializerFactory withAdditionalKeySerializers(Serializers additional)

  Convenience method for creating a new factory instance with an additional key serializer provider.

  Specified by:
    `withAdditionalKeySerializers` in class `SerializerFactory`

### withSerializerModifier

    public final SerializerFactory withSerializerModifier(BeanSerializerModifier modifier)

  Convenience method for creating a new factory instance with additional bean serializer modifier.

  Specified by:
    `withSerializerModifier` in class `SerializerFactory`

### createSerializer

    public abstract JsonSerializer<Object> createSerializer(SerializerProvider prov,
                                                            JavaType type,
                                                            BeanProperty property)
                                                     throws JsonMappingException

  Description copied from class: `SerializerFactory`
  Method called to create (or, for immutable serializers, reuse) a serializer for given type.

  Specified by:
    `createSerializer` in class `SerializerFactory`
  Parameters:
    `prov` - Provider that needs to be used to resolve annotation-provided serializers (but NOT for others)
  Throws:
    `JsonMappingException`

### createKeySerializer

    public JsonSerializer<Object> createKeySerializer(SerializationConfig config,
                                                      JavaType type)

  Description copied from class: `SerializerFactory`
  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)

  Specified by:
    `createKeySerializer` in class `SerializerFactory`
    `type` - Declared type for Map keys
  Returns:
    Serializer to use, if factory knows it; null if not (in which case default serializer is to be used)

### createTypeSerializer

    public TypeSerializer createTypeSerializer(SerializationConfig config,
                                               JavaType baseType)

  Method called to construct a type serializer for values with given declared base type. This is called for values other than those of bean property types.

  Specified by:
    `createTypeSerializer` in class `SerializerFactory`
    `baseType` - Declared type to use as the base type for type information serializer
  Returns:
    Type serializer to use for the base type, if one is needed; null if not.

### getNullSerializer

    public final JsonSerializer<?> getNullSerializer()

### customSerializers

    protected abstract Iterable<Serializers> customSerializers()

### findSerializerByLookup

    protected final JsonSerializer<?> 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.

### findSerializerByAnnotations

    protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov,
                                                                  JavaType type,
                                                                  BeanDescription beanDesc)
                                                           throws JsonMappingException

  Method called to see if one of primary per-class annotations (or related, like implementing of `JsonSerializable`) determines the serializer to use.

  Currently handles things like:

  - If type implements `JsonSerializable`, use that
  - If type has `JsonValue` annotation (or equivalent), build serializer based on that property

  Throws:
    `JsonMappingException`
  Since:
    2.0

### findSerializerByPrimaryType

    protected final JsonSerializer<?> findSerializerByPrimaryType(SerializerProvider prov,
                                                                  JavaType type,
                                                                  BeanDescription beanDesc,
                                                                  boolean staticTyping)
                                                           throws JsonMappingException

  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`). This does not include "secondary" interfaces, but mostly concrete or abstract base classes.

  Throws:
    `JsonMappingException`

### findSerializerByAddonType

    protected final JsonSerializer<?> findSerializerByAddonType(SerializationConfig config,
                                                                JavaType javaType,
                                                                BeanDescription beanDesc,
                                                                boolean staticTyping)
                                                         throws JsonMappingException

  Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces. Add-on here means a role that is usually or can be a secondary trait: for example, bean classes may implement `Iterable`, but their main function is usually something else. The reason for

  Throws:
    `JsonMappingException`

### findSerializerFromAnnotation

    protected JsonSerializer<Object> findSerializerFromAnnotation(SerializerProvider prov,
                                                                  Annotated a)
                                                           throws JsonMappingException

  Helper method called to check if a class or method has an annotation (@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using) that tells the class to use for serialization. Returns null if no such annotation found.

  Throws:
    `JsonMappingException`

### buildContainerSerializer

    protected JsonSerializer<?> buildContainerSerializer(SerializerProvider prov,
                                                         JavaType type,
                                                         BeanDescription beanDesc,
                                                         BeanProperty property,
                                                         boolean staticTyping)
                                                  throws JsonMappingException

  Throws:
    `JsonMappingException`

### buildCollectionSerializer

    protected JsonSerializer<?> buildCollectionSerializer(SerializationConfig config,
                                                          CollectionType type,
                                                          BeanDescription beanDesc,
                                                          BeanProperty property,
                                                          boolean staticTyping,
                                                          TypeSerializer elementTypeSerializer,
                                                          JsonSerializer<Object> elementValueSerializer)
                                                   throws JsonMappingException

  Helper method that handles configuration details when constructing serializers for `List` types that support efficient by-index access

  Throws:
    `JsonMappingException`

### isIndexedList

    protected boolean isIndexedList(Class<?> cls)

### buildMapSerializer

    protected JsonSerializer<?> buildMapSerializer(SerializationConfig config,
                                                   MapType type,
                                                   BeanDescription beanDesc,
                                                   boolean staticTyping,
                                                   JsonSerializer<Object> keySerializer,
                                                   TypeSerializer elementTypeSerializer,
                                                   JsonSerializer<Object> elementValueSerializer)
                                            throws JsonMappingException

  Helper method that handles configuration details when constructing serializers for `Map` types.

  Throws:
    `JsonMappingException`

### buildArraySerializer

    protected JsonSerializer<?> buildArraySerializer(SerializationConfig config,
                                                     ArrayType type,
                                                     BeanDescription beanDesc,
                                                     boolean staticTyping,
                                                     TypeSerializer elementTypeSerializer,
                                                     JsonSerializer<Object> elementValueSerializer)
                                              throws JsonMappingException

  Helper method that handles configuration details when constructing serializers for `Object[]` (and subtypes, except for String).

  Throws:
    `JsonMappingException`

### buildIteratorSerializer

    protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config,
                                                        JavaType type,
                                                        BeanDescription beanDesc,
                                                        boolean staticTyping)
                                                 throws JsonMappingException

  Throws:
    `JsonMappingException`

### buildIterableSerializer

    protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config,
                                                        JavaType type,
                                                        BeanDescription beanDesc,
                                                        boolean staticTyping)
                                                 throws JsonMappingException

  Throws:
    `JsonMappingException`

### modifyTypeByAnnotation

    protected <T extends JavaType> T modifyTypeByAnnotation(SerializationConfig config,
                                                            Annotated a,
                                                            T type)

  Helper method used to encapsulate details of annotation-based type coercion

### modifySecondaryTypesByAnnotation

    protected static <T extends JavaType> T modifySecondaryTypesByAnnotation(SerializationConfig config,
                                                                             Annotated a,
                                                                             T type)

### _findKeySerializer

    protected JsonSerializer<Object> _findKeySerializer(SerializerProvider prov,
                                                        Annotated a,
                                                        BeanProperty property)
                                                 throws JsonMappingException

  Throws:
    `JsonMappingException`

### _findContentSerializer

    protected JsonSerializer<Object> _findContentSerializer(SerializerProvider prov,
                                                            Annotated a,
                                                            BeanProperty property)
                                                     throws JsonMappingException

  Throws:
    `JsonMappingException`

### usesStaticTyping

    protected boolean usesStaticTyping(SerializationConfig config,
                                       BeanDescription beanDesc,
                                       TypeSerializer typeSer,
                                       BeanProperty property)

  Helper method to check whether global settings and/or class annotations for the bean class indicate that static typing (declared types) should be used for properties. (instead of dynamic runtime types).

### _verifyAsClass

    protected Class<?> _verifyAsClass(Object src,
                                      String methodName,
                                      Class<?> noneClass)

Copyright © 2012 fasterxml.com. All Rights Reserved.