下面列出了com.fasterxml.jackson.databind.ser.Serializers#com.fasterxml.jackson.databind.jsontype.TypeSerializer 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException {
TypeSerializer vts = valueTypeSerializer;
if (vts != null) {
vts = vts.forProperty(property);
}
JsonSerializer<?> ser = valueSerializer;
if (ser == null) {
// A few conditions needed to be able to fetch serializer here:
if (useStatic(provider, property, valueType)) {
ser = provider.findTypedValueSerializer(valueType, true, property);
}
} else {
ser = provider.handlePrimaryContextualization(ser, property);
}
return new LazySerializer(fullType, valueType, vts, ser);
}
/**
* Method called to create a type information serializer for values of given
* container property
* if one is needed. If not needed (no polymorphic handling configured), should
* return null.
*
* @param containerType Declared type of the container to use as the base type for type information serializer
*
* @return Type serializer to use for property value contents, if one is needed; null if not.
*/
public TypeSerializer findPropertyContentTypeSerializer(JavaType containerType,
SerializationConfig config, AnnotatedMember accessor)
throws JsonMappingException
{
JavaType contentType = containerType.getContentType();
AnnotationIntrospector ai = config.getAnnotationIntrospector();
TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, accessor, containerType);
TypeSerializer typeSer;
// Defaulting: if no annotations on member, check value class
if (b == null) {
typeSer = createTypeSerializer(config, contentType);
} else {
Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypesByClass(config,
accessor, contentType);
typeSer = b.buildTypeSerializer(config, contentType, subtypes);
}
return typeSer;
}
/**
* Helper method called to ensure that we do not have "duplicate" type ids.
* Added to resolve [databind#222]
*
* @since 2.6
*/
protected List<BeanPropertyWriter> removeOverlappingTypeIds(SerializerProvider prov,
BeanDescription beanDesc, BeanSerializerBuilder builder,
List<BeanPropertyWriter> props)
{
for (int i = 0, end = props.size(); i < end; ++i) {
BeanPropertyWriter bpw = props.get(i);
TypeSerializer td = bpw.getTypeSerializer();
if ((td == null) || (td.getTypeInclusion() != As.EXTERNAL_PROPERTY)) {
continue;
}
String n = td.getPropertyName();
PropertyName typePropName = PropertyName.construct(n);
for (BeanPropertyWriter w2 : props) {
if ((w2 != bpw) && w2.wouldConflictWithName(typePropName)) {
bpw.assignTypeSerializer(null);
break;
}
}
}
return props;
}
protected void _serializeObjectId(Object bean, JsonGenerator g,
SerializerProvider provider,
TypeSerializer typeSer, WritableObjectId objectId) throws IOException
{
final ObjectIdWriter w = _objectIdWriter;
WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_OBJECT);
typeSer.writeTypePrefix(g, typeIdDef);
objectId.writeAsField(g, provider, w);
if (_propertyFilterId != null) {
serializeFieldsFiltered(bean, g, provider);
} else {
serializeFields(bean, g, provider);
}
typeSer.writeTypeSuffix(g, typeIdDef);
}
/**
* @deprecated Since 2.6 Use variants that either take 'src', or do NOT pass
* BeanProperty
*/
@Deprecated
protected AsArraySerializerBase(Class<?> cls, JavaType et, boolean staticTyping,
TypeSerializer vts, BeanProperty property, JsonSerializer<Object> elementSerializer)
{
// typing with generics is messy... have to resort to this:
super(cls, false);
_elementType = et;
// static if explicitly requested, or if element type is final
_staticTyping = staticTyping || (et != null && et.isFinal());
_valueTypeSerializer = vts;
_property = property;
_elementSerializer = elementSerializer;
_dynamicSerializers = PropertySerializerMap.emptyForProperties();
_unwrapSingle = null;
}
@Override
public void serializeWithType(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
typeSer.typeId(value, JsonToken.START_OBJECT));
if (!value.isEmpty()) {
if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
value = _orderEntries(value, gen, provider);
}
PropertyFilter pf;
if ((_filterId != null) && (pf = findPropertyFilter(provider, _filterId, value)) != null) {
serializeFilteredFields(value, gen, provider, pf, _suppressableValue);
} else if ((_suppressableValue != null) || _suppressNulls) {
serializeOptionalFields(value, gen, provider, _suppressableValue);
} else if (_valueSerializer != null) {
serializeFieldsUsing(value, gen, provider, _valueSerializer);
} else {
serializeFields(value, gen, provider);
}
}
typeSer.writeTypeSuffix(gen, typeIdDef);
}
@Override
public void serializeWithType(
AwsCredentialsProvider credentialsProvider,
JsonGenerator jsonGenerator,
SerializerProvider serializer,
TypeSerializer typeSerializer)
throws IOException {
WritableTypeId typeId =
typeSerializer.writeTypePrefix(
jsonGenerator, typeSerializer.typeId(credentialsProvider, JsonToken.START_OBJECT));
if (credentialsProvider.getClass().equals(StaticCredentialsProvider.class)) {
jsonGenerator.writeStringField(
ACCESS_KEY_ID, credentialsProvider.resolveCredentials().accessKeyId());
jsonGenerator.writeStringField(
SECRET_ACCESS_KEY, credentialsProvider.resolveCredentials().secretAccessKey());
} else if (!SINGLETON_CREDENTIAL_PROVIDERS.contains(credentialsProvider.getClass())) {
throw new IllegalArgumentException(
"Unsupported AWS credentials provider type " + credentialsProvider.getClass());
}
typeSerializer.writeTypeSuffix(jsonGenerator, typeId);
}
public void serializeTypedContents(Object[] value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.length;
final TypeSerializer typeSer = _valueTypeSerializer;
int i = 0;
Object elem = null;
try {
PropertySerializerMap serializers = _dynamicSerializers;
for (; i < len; ++i) {
elem = value[i];
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializer.serializeWithType(elem, jgen, provider, typeSer);
}
} catch (Exception e) {
wrapAndThrow(provider, e, elem, i);
}
}
@Override
public void serializeWithType(Multimap<?,?> value, JsonGenerator gen,
SerializerProvider ctxt, TypeSerializer typeSer)
throws IOException
{
gen.setCurrentValue(value);
WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen, ctxt,
typeSer.typeId(value, JsonToken.START_OBJECT));
if (!value.isEmpty()) {
// 20-Mar-2017, tatu: And this is where [datatypes-collections#7] would be
// plugged in...
// if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
// value = _orderEntries(value, gen, provider);
// }
if (_filterId != null) {
serializeFilteredFields(value, gen, ctxt);
} else {
serializeFields(value, gen, ctxt);
}
}
typeSer.writeTypeSuffix(gen, ctxt, typeIdDef);
}
@Override
public void serializeWithType(Object value, JsonGenerator gen,
SerializerProvider provider, TypeSerializer typeSer)
throws IOException {
// no type info, just regular serialization
serialize(value, gen, provider);
}
@Override
public void serializeWithType(JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(this, asToken()));
serialize(g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException, JsonProcessingException
{
// No type for JSONP wrapping: value serializer will handle typing for value:
serialize(jgen, provider);
}
@Deprecated // since 2.8
protected VirtualBeanPropertyWriter(BeanPropertyDefinition propDef,
Annotations contextAnnotations, JavaType declaredType,
JsonSerializer<?> ser, TypeSerializer typeSer, JavaType serType,
JsonInclude.Value inclusion)
{
this(propDef, contextAnnotations, declaredType, ser, typeSer, serType, inclusion, null);
}
@Override
public void serializeWithType(Node value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException {
WritableTypeId typeId = typeSer.typeId(value, Node.class, JsonToken.START_OBJECT);
typeSer.writeTypePrefix(gen, typeId);
serialize(value, gen, serializers);
typeSer.writeTypeSuffix(gen, typeId);
}
@Override
public TypeSerializer buildTypeSerializer(SerializationConfig config, JavaType baseType,
Collection<NamedType> subtypes) {
isAutowiredFiledInitialized = (this.capitalizer != null);
return super.buildTypeSerializer(config, baseType, subtypes);
}
@Override
public JsonSerializer<?> findCollectionSerializer(SerializationConfig config,
CollectionType type, BeanDescription beanDesc,
TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
{
return null;
}
@Override
public void serializeWithType(JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer)
throws IOException
{
// No type for JSONP wrapping: value serializer will handle typing for value:
serialize(gen, provider);
}
protected EvalSerializer(EvalSerializer base, BeanProperty property,
TypeSerializer vts, JsonSerializer<?> valueSer, NameTransformer unwrapper,
Object suppressableValue, boolean suppressNulls)
{
super(base, property, vts, valueSer, unwrapper,
suppressableValue, suppressNulls);
}
@Override
public final void serializeWithType(Object value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) {
failForEmpty(provider, value);
}
WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
typeSer.typeId(value, JsonToken.START_OBJECT));
typeSer.writeTypeSuffix(gen, typeIdDef);
}
protected TableSerializer withResolved(final BeanProperty property,
final TypeFactory typeFactory,
final JsonSerializer<?> rowKeySer,
final JsonSerializer<?> columnKeySer,
final TypeSerializer vts,
final JsonSerializer<?> valueSer )
{
return new TableSerializer(this, property, typeFactory,
rowKeySer, columnKeySer, vts, valueSer);
}
@Override
public TypeSerializer buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes) {
//Copied this code from parent class, StdTypeResolverBuilder with same method name
TypeIdResolver idRes = this.idResolver(config, baseType, subtypes, true, false);
// have to escape "." in the middle of the "odata.type" otherwise it will be serialized to "odata": { "type":"Value"} JSON
String escapedString = this._typeProperty.replace(".", "\\.");
return new AsPropertyTypeSerializer(idRes, (BeanProperty) null, escapedString);
}
@Override
public void serializeWithType(List<String> value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.START_ARRAY));
serializeContents(value, g, provider, value.size());
typeSer.writeTypeSuffix(g, typeIdDef);
}
/**
* Method called to locate regular serializer, matching type serializer,
* and if both found, wrap them in a serializer that calls both in correct
* sequence. This method is currently only used for root-level serializer
* handling to allow for simpler caching. A call can always be replaced
* by equivalent calls to access serializer and type serializer separately.
*
* @param valueType Type for purpose of locating a serializer; usually dynamic
* runtime type, but can also be static declared type, depending on configuration
* @param cache Whether resulting value serializer should be cached or not; this is just
* a hint
* @param property When creating secondary serializers, property for which
* serializer is needed: annotations of the property (or bean that contains it)
* may be checked to create contextual serializers.
*/
public JsonSerializer<Object> findTypedValueSerializer(Class<?> valueType,
boolean cache, BeanProperty property)
throws JsonMappingException
{
// Two-phase lookups; local non-shared cache, then shared:
JsonSerializer<Object> ser = _knownSerializers.typedValueSerializer(valueType);
if (ser != null) {
return ser;
}
// If not, maybe shared map already has it?
ser = _serializerCache.typedValueSerializer(valueType);
if (ser != null) {
return ser;
}
// Well, let's just compose from pieces:
ser = findValueSerializer(valueType, property);
TypeSerializer typeSer = _serializerFactory.createTypeSerializer(_config,
_config.constructType(valueType));
if (typeSer != null) {
typeSer = typeSer.forProperty(property);
ser = new TypeWrappedSerializer(typeSer, ser);
}
if (cache) {
_serializerCache.addTypedSerializer(valueType, ser);
}
return ser;
}
@Override
public void serializeWithType(T value, JsonGenerator gen, SerializerProvider ctxt, TypeSerializer typeSer)
throws IOException {
WritableTypeId typeIdDef = typeSer.writeTypePrefix(
gen, ctxt, typeSer.typeId(value, JsonToken.START_OBJECT));
serializeEntries(value, gen, ctxt);
typeSer.writeTypeSuffix(gen, ctxt, typeIdDef);
}
protected AtomicReferenceSerializer(AtomicReferenceSerializer base, BeanProperty property,
TypeSerializer vts, JsonSerializer<?> valueSer,
NameTransformer unwrapper,
Object suppressableValue, boolean suppressNulls)
{
super(base, property, vts, valueSer, unwrapper,
suppressableValue, suppressNulls);
}
@Override
public void serializeWithType(OffsetTime value, JsonGenerator g, SerializerProvider ctxt,
TypeSerializer typeSer) throws IOException
{
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g, ctxt,
typeSer.typeId(value, serializationShape(ctxt)));
// need to write out to avoid double-writing array markers
if (typeIdDef.valueShape == JsonToken.START_ARRAY) {
_serializeAsArrayContents(value, g, ctxt);
} else {
String str = (_formatter == null) ? value.toString() : value.format(_formatter);
g.writeString(str);
}
typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
@Override
public JsonSerializer<?> findArraySerializer(SerializationConfig config,
ArrayType type, BeanDescription beanDesc,
TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
{
return null;
}
@Override
public final void serializeWithType(T value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
// no type info, just regular serialization
serialize(value, gen, provider);
}
/**
* @since 2.5
* @deprecated // since 2.9
*/
@Deprecated // since 2.9
protected MapSerializer(MapSerializer src, TypeSerializer vts,
Object suppressableValue)
{
this(src, vts, suppressableValue, false);
}
/****
* 序列化需要类型形式时，即objectMapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY)，必须实现此方法
*/
@Override
public void serializeWithType(Object value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException {
typeSer.writeTypePrefixForScalar(value, gen);
serialize(value, gen, serializers);
// typeSer.writeTypePrefixForScalar(value, gen);
typeSer.writeTypeSuffixForScalar(value, gen);
}