private final JsonSerializer<Object> _findSerializer(SerializerProvider provider, JavaType type, BeanProperty prop) throws JsonMappingException { // 13-Mar-2017, tatu: Used to call `findTypeValueSerializer()`, but contextualization // not working for that case for some reason // 15-Jan-2017, tatu: ... possibly because we need to access "secondary" serializer, // not primary (primary being one for Reference type itself, not value) // return provider.findTypedValueSerializer(type, true, prop); return provider.findValueSerializer(type, prop); } }
/** * Helper method used for locating serializer to use in dynamic use case, where * actual type value gets converted to is not specified beyond basic * {@link java.lang.Object}, and where serializer needs to be located dynamically * based on actual value type. * * @since 2.6 */ protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers) throws JsonMappingException { // NOTE: will NOT call contextualization return serializers.findValueSerializer(value.getClass()); } }
@Override public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator gen, SerializerProvider provider) throws IOException { JsonSerializer<Object> enumSer = _elementSerializer; /* Need to dynamically find instance serializer; unfortunately * that seems to be the only way to figure out type (no accessors * to the enum class that set knows) */ for (Enum<?> en : value) { if (enumSer == null) { /* 12-Jan-2010, tatu: Since enums cannot be polymorphic, let's * not bother with typed serializer variant here */ enumSer = provider.findValueSerializer(en.getDeclaringClass(), _property); } enumSer.serialize(en, gen, provider); } } }
private SchemaAware getValueSerializer(Object valueAsJavaType) throws JsonMappingException { SerializerProvider serializerProvider = new DefaultSerializerProvider.Impl().createInstance(this.objectMapper.getSerializationConfig(), BeanSerializerFactory.instance); if (valueAsJavaType == null) { return NullSerializer.instance; } else if (valueAsJavaType instanceof Long) { // longs are 'integers' in schema terms JsonSerializer<Object> valueSerializer = serializerProvider.findValueSerializer(Integer.class, null); return (SchemaAware) valueSerializer; } else { Class<? extends Object> javaTypeForValue = valueAsJavaType.getClass(); JsonSerializer<Object> valueSerializer = serializerProvider.findValueSerializer(javaTypeForValue, null); return (SchemaAware) valueSerializer; } }
@Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonSerializer<?> valueSer = _elementSerializer; if (valueSer == null) { // 19-Oct-2016, tatu: Apparently we get null for untyped/raw `EnumSet`s... not 100% // sure what'd be the clean way but let's try this for now: if (_elementType != null) { valueSer = visitor.getProvider().findValueSerializer(_elementType, _property); } } visitArrayFormat(visitor, typeHint, valueSer, _elementType); }
/** * Method called if initial lookup fails, when looking for a non-primary * serializer (one that is not directly attached to a property). * Will both find serializer * and construct new map instance if warranted, and return both. * * @since 2.3 * * @throws JsonMappingException */ public final SerializerAndMapResult findAndAddSecondarySerializer(Class<?> type, SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<Object> serializer = provider.findValueSerializer(type, property); return new SerializerAndMapResult(serializer, newWith(type, serializer)); }
@Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JavaType propertyType = property.getType(); if (Score.class.equals(propertyType.getRawClass())) { // If the property type is Score (not HardSoftScore for example), // delegate to PolymorphicScoreJacksonJsonSerializer instead to write the score type too // This presumes that OptaPlannerJacksonModule is registered return provider.findValueSerializer(propertyType); } return this; }
@Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JavaType propertyType = property.getType(); if (Score.class.equals(propertyType.getRawClass())) { // If the property type is Score (not HardSoftScore for example), // delegate to PolymorphicScoreJacksonJsonSerializer instead to write the score type too // This presumes that OptaPlannerJacksonModule is registered return provider.findValueSerializer(propertyType); } return this; }
currSerializer = prevSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevSerializer = currSerializer; prevClass = cc;
public final SerializerAndMapResult findAndAddSecondarySerializer(JavaType type, SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<Object> serializer = provider.findValueSerializer(type, property); return new SerializerAndMapResult(serializer, newWith(type.getRawClass(), serializer)); }
@Override protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map, Class<?> type, SerializerProvider provider) throws JsonMappingException { JsonSerializer<Object> serializer; if (_nonTrivialBaseType != null) { JavaType subtype = provider.constructSpecializedType(_nonTrivialBaseType, type); serializer = provider.findValueSerializer(subtype, this); } else { serializer = provider.findValueSerializer(type, this); } NameTransformer t = _nameTransformer; if (serializer.isUnwrappingSerializer() // as per [databind#2060], need to also check this, in case someone writes // custom implementation that does not extend standard implementation: && (serializer instanceof UnwrappingBeanSerializer)) { t = NameTransformer.chainedTransformer(t, ((UnwrappingBeanSerializer) serializer)._nameTransformer); } serializer = serializer.unwrappingSerializer(t); _dynamicSerializers = _dynamicSerializers.newWith(type, serializer); return serializer; } }
/** * Helper method that encapsulates logic of retrieving and caching required * serializer. */ private final JsonSerializer<Object> _findCachedSerializer(SerializerProvider provider, Class<?> rawType) throws JsonMappingException { JsonSerializer<Object> ser = _dynamicSerializers.serializerFor(rawType); if (ser == null) { // NOTE: call this instead of `map._findAndAddDynamic(...)` (which in turn calls // `findAndAddSecondarySerializer`) since we may need to apply unwrapper // too, before caching. But calls made are the same if (_referredType.hasGenericTypes()) { // [databind#1673] Must ensure we will resolve all available type information // so as not to miss generic declaration of, say, `List<GenericPojo>`... JavaType fullType = provider.constructSpecializedType(_referredType, rawType); ser = provider.findValueSerializer(fullType, _property); } else { ser = provider.findValueSerializer(rawType, _property); } if (_unwrapper != null) { ser = ser.unwrappingSerializer(_unwrapper); } _dynamicSerializers = _dynamicSerializers.newWith(rawType, ser); } return ser; }
@Override public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException { JsonArrayFormatVisitor arrayVisitor = visitor.expectArrayFormat(typeHint); if (arrayVisitor != null) { JavaType contentType = _elementType; // [databind#1793]: Was getting `null` for `typeHint`. But why would we even use it... /* TypeFactory tf = visitor.getProvider().getTypeFactory(); contentType = tf.moreSpecificType(_elementType, typeHint.getContentType()); if (contentType == null) { visitor.getProvider().reportBadDefinition(_elementType, "Could not resolve type: "+_elementType); } */ JsonSerializer<?> valueSer = _elementSerializer; if (valueSer == null) { valueSer = visitor.getProvider().findValueSerializer(contentType, _property); } arrayVisitor.itemsFormat(valueSer, contentType); } }
@Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { JsonSerializer<?> delSer = _delegateSerializer; JavaType delegateType = _delegateType; if (delSer == null) { // Otherwise, need to locate serializer to delegate to. For that we need type information... if (delegateType == null) { delegateType = _converter.getOutputType(provider.getTypeFactory()); } // 02-Apr-2015, tatu: For "dynamic case", where type is only specified as // java.lang.Object (or missing generic), [databind#731] if (!delegateType.isJavaLangObject()) { delSer = provider.findValueSerializer(delegateType); } } if (delSer instanceof ContextualSerializer) { delSer = provider.handleSecondaryContextualization(delSer, property); } if (delSer == _delegateSerializer && delegateType == _delegateType) { return this; } return withDelegate(_converter, delegateType, delSer); }
@Override public void depositSchemaProperty(final JsonObjectFormatVisitor visitor, SerializerProvider provider) throws JsonMappingException { JsonSerializer<Object> ser = provider .findValueSerializer(this.getType(), this) .unwrappingSerializer(_nameTransformer); if (ser.isUnwrappingSerializer()) { ser.acceptJsonFormatVisitor(new JsonFormatVisitorWrapper.Base(provider) { // an unwrapping serializer will always expect ObjectFormat, // hence, the other cases do not have to be implemented @Override public JsonObjectFormatVisitor expectObjectFormat(JavaType type) throws JsonMappingException { return visitor; } }, this.getType()); } else { super.depositSchemaProperty(visitor, provider); } }
ser = provider.findValueSerializer(getType(), this);
/** * @deprecated Since 2.9 use {link {@link #findContextualConvertingSerializer} instead */ @Deprecated protected JsonSerializer<?> findConvertingContentSerializer(SerializerProvider provider, BeanProperty prop, JsonSerializer<?> existingSerializer) throws JsonMappingException { final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if (_neitherNull(intr, prop)) { AnnotatedMember m = prop.getMember(); if (m != null) { Object convDef = intr.findSerializationContentConverter(m); if (convDef != null) { Converter<Object,Object> conv = provider.converterInstance(prop.getMember(), convDef); JavaType delegateType = conv.getOutputType(provider.getTypeFactory()); // [databind#731]: Should skip if nominally java.lang.Object if ((existingSerializer == null) && !delegateType.isJavaLangObject()) { existingSerializer = provider.findValueSerializer(delegateType); } return new StdDelegatingSerializer(conv, delegateType, existingSerializer); } } } return existingSerializer; }
ser = provider.findValueSerializer(value.getClass(), _property); } else {
/** * Helper method that can be used to see if specified property is annotated * to indicate use of a converter for property value (in case of container types, * it is container type itself, not key or content type). * * @since 2.2 */ protected JsonSerializer<Object> findConvertingSerializer(SerializerProvider provider, BeanPropertyWriter prop) throws JsonMappingException { final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if (intr != null) { AnnotatedMember m = prop.getMember(); if (m != null) { Object convDef = intr.findSerializationConverter(m); if (convDef != null) { Converter<Object,Object> conv = provider.converterInstance(prop.getMember(), convDef); JavaType delegateType = conv.getOutputType(provider.getTypeFactory()); // [databind#731]: Should skip if nominally java.lang.Object JsonSerializer<?> ser = delegateType.isJavaLangObject() ? null : provider.findValueSerializer(delegateType, prop); return new StdDelegatingSerializer(conv, delegateType, ser); } } } return null; }
ser = serializers.findValueSerializer(String.class, property);