Module tools.jackson.databind

Package tools.jackson.databind.ser

Class SerializerCache

java.lang.Object

tools.jackson.databind.ser.SerializerCache

All Implemented Interfaces:

Serializable, Snapshottable<SerializerCache>

public final class SerializerCache
extends Object
implements Snapshottable<SerializerCache>, Serializable

Simple cache object that allows for doing 2-level lookups: first level is by "local" read-only lookup Map (used without locking) and second backup level is by a shared modifiable HashMap. The idea is that after a while, most serializers are found from the local Map (to optimize performance, reduce lock contention), but that during buildup we can use a shared map to reduce both number of distinct read-only maps constructed, and number of serializers constructed.

Cache contains three kinds of entries, based on combination of class pair key. First class in key is for the type to serialize, and second one is type used for determining how to resolve value type. One (but not both) of entries can be null.

To prevent threads from observing partially-resolved serializers during addAndResolveNonTypedSerializer(java.lang.Class<?>, tools.jackson.databind.ValueSerializer<java.lang.Object>, tools.jackson.databind.SerializationContext) calls, a two-phase write protocol is used: newly constructed serializers are placed into _inProgressMap first, resolved there (so cyclic POJO lookups can find the in-progress entry), and only moved to _sharedMap after resolve() completes. Each entry is removed from _inProgressMap as soon as it is promoted, so the map tends to stay empty at steady state. The lock-free read path (untypedValueSerializer(java.lang.Class<?>)) reads only from _sharedMap, which therefore never contains a partially-resolved serializer.

See Also:

• Serialized Form

Field Summary

Fields

Modifier and Type	Field	Description
static final int	DEFAULT_MAX_CACHE_SIZE	By default, allow caching of up to 4000 serializer entries (for possibly up to 1000 types; but depending access patterns may be as few as half of that).

Constructor Summary

Constructors

Modifier	Constructor	Description
	SerializerCache()
	SerializerCache(int maxCached)
	SerializerCache(LookupCache<TypeKey,ValueSerializer<Object>> cache)
protected	SerializerCache(SimpleLookupCache<TypeKey,ValueSerializer<Object>> shared)

Method Summary

Modifier and Type	Method	Description
void	addAndResolveNonTypedSerializer(Class<?> rawType, JavaType fullType, ValueSerializer<Object> ser, SerializationContext ctxt)	Another alternative that will cover both access via raw type and matching fully resolved type, in one fell swoop.
void	addAndResolveNonTypedSerializer(Class<?> type, ValueSerializer<Object> ser, SerializationContext ctxt)
void	addAndResolveNonTypedSerializer(JavaType type, ValueSerializer<Object> ser, SerializationContext ctxt)
void	addTypedSerializer(Class<?> cls, ValueSerializer<Object> ser)
void	addTypedSerializer(JavaType type, ValueSerializer<Object> ser)	Method called if none of lookups succeeded, and caller had to construct a serializer.
void	flush()	Method called by StdSerializationContext#flushCachedSerializers() to clear all cached serializers
ReadOnlyClassToSerializerMap	getReadOnlyLookupMap()	Method that can be called to get a read-only instance populated from the most recent version of the shared lookup Map.
protected Object	readResolve()
int	size()
SerializerCache	snapshot()
ValueSerializer<Object>	typedValueSerializer(Class<?> cls)	Method that checks if the shared (and hence, synchronized) lookup Map might have a typed serializer for given type.
ValueSerializer<Object>	typedValueSerializer(JavaType type)	Method that checks if the shared (and hence, synchronized) lookup Map might have a typed serializer for given type.
ValueSerializer<Object>	untypedValueSerializer(Class<?> type)	Returns the fully-resolved untyped serializer for the given type, or null if not yet cached.
ValueSerializer<Object>	untypedValueSerializer(JavaType type)	Returns the fully-resolved untyped serializer for the given type, or null if not yet cached.

Methods inherited from class java.lang.Object

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

Field Details

DEFAULT_MAX_CACHE_SIZE

public static final int DEFAULT_MAX_CACHE_SIZE

By default, allow caching of up to 4000 serializer entries (for possibly up to 1000 types; but depending access patterns may be as few as half of that).

See Also:

• Constant Field Values

Constructor Details

SerializerCache

public SerializerCache()

SerializerCache

public SerializerCache(int maxCached)

Since:

3.0

SerializerCache

public SerializerCache(LookupCache<TypeKey,ValueSerializer<Object>> cache)

SerializerCache

protected SerializerCache(SimpleLookupCache<TypeKey,ValueSerializer<Object>> shared)

Method Details

readResolve

protected Object readResolve()

snapshot

public SerializerCache snapshot()

Specified by:

snapshot in interface Snapshottable<SerializerCache>

getReadOnlyLookupMap

public ReadOnlyClassToSerializerMap getReadOnlyLookupMap()

Method that can be called to get a read-only instance populated from the most recent version of the shared lookup Map.

size

public int size()

untypedValueSerializer

public ValueSerializer<Object> untypedValueSerializer(Class<?> type)

Returns the fully-resolved untyped serializer for the given type, or null if not yet cached. Reads from _sharedMap which only contains fully-resolved entries, so no lock is needed.

During cyclic POJO resolution the resolving thread may re-enter this method before the in-progress serializer has been promoted to _sharedMap. In that case, because the calling thread already holds the monitor (via synchronized (this) in addAndResolveNonTypedSerializer(java.lang.Class<?>, tools.jackson.databind.ValueSerializer<java.lang.Object>, tools.jackson.databind.SerializationContext)), Thread.holdsLock(java.lang.Object) is true and we fall back to _inProgressMap to return the partially-resolved serializer to break the cycle. All other threads never hold the monitor and therefore exclusively see fully-resolved entries.

untypedValueSerializer

public ValueSerializer<Object> untypedValueSerializer(JavaType type)

Returns the fully-resolved untyped serializer for the given type, or null if not yet cached. Reads from _sharedMap which only contains fully-resolved entries, so no lock is needed.

During cyclic POJO resolution the resolving thread may re-enter this method before the in-progress serializer has been promoted to _sharedMap. In that case, because the calling thread already holds the monitor (via synchronized (this) in addAndResolveNonTypedSerializer(java.lang.Class<?>, tools.jackson.databind.ValueSerializer<java.lang.Object>, tools.jackson.databind.SerializationContext)), Thread.holdsLock(java.lang.Object) is true and we fall back to _inProgressMap to return the partially-resolved serializer to break the cycle. All other threads never hold the monitor and therefore exclusively see fully-resolved entries.

typedValueSerializer

public ValueSerializer<Object> typedValueSerializer(JavaType type)

Method that checks if the shared (and hence, synchronized) lookup Map might have a typed serializer for given type.

typedValueSerializer

public ValueSerializer<Object> typedValueSerializer(Class<?> cls)

Method that checks if the shared (and hence, synchronized) lookup Map might have a typed serializer for given type.

addTypedSerializer

public void addTypedSerializer(JavaType type,
 ValueSerializer<Object> ser)

Method called if none of lookups succeeded, and caller had to construct a serializer. If so, we will update the shared lookup map so that it can be resolved via it next time.

addTypedSerializer

public void addTypedSerializer(Class<?> cls,
 ValueSerializer<Object> ser)

addAndResolveNonTypedSerializer

public void addAndResolveNonTypedSerializer(Class<?> type,
 ValueSerializer<Object> ser,
 SerializationContext ctxt)

addAndResolveNonTypedSerializer

public void addAndResolveNonTypedSerializer(JavaType type,
 ValueSerializer<Object> ser,
 SerializationContext ctxt)

addAndResolveNonTypedSerializer

public void addAndResolveNonTypedSerializer(Class<?> rawType,
 JavaType fullType,
 ValueSerializer<Object> ser,
 SerializationContext ctxt)

Another alternative that will cover both access via raw type and matching fully resolved type, in one fell swoop.

flush

public void flush()

Method called by StdSerializationContext#flushCachedSerializers() to clear all cached serializers