final SerializationConfig config = prov.getConfig(); BeanDescription beanDesc = config.introspect(origType); JsonSerializer<?> ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } else { try { type = intr.refineSerializationType(config, beanDesc.getClassInfo(), origType); } catch (JsonMappingException e) { return prov.reportBadTypeDefinition(beanDesc, e.getMessage()); } else { // changes; assume static typing; plus, need to re-introspect if class differs staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); ser = _createSerializer2(prov, delegateType, beanDesc, true); return new StdDelegatingSerializer(conv, delegateType, ser);
@Override public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException { Object delegateValue = convertValue(value); // should we accept nulls? if (delegateValue == null) { provider.defaultSerializeNull(gen); return; } // 02-Apr-2015, tatu: As per [databind#731] may need to do dynamic lookup JsonSerializer<Object> ser = _delegateSerializer; if (ser == null) { ser = _findSerializer(delegateValue, provider); } ser.serialize(delegateValue, gen, provider); }
@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 serializeWithType(Object value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException { /* 03-Oct-2012, tatu: This is actually unlikely to work ok... but for now, * let's give it a chance? */ Object delegateValue = convertValue(value); JsonSerializer<Object> ser = _delegateSerializer; if (ser == null) { ser = _findSerializer(value, provider); } ser.serializeWithType(delegateValue, gen, provider, typeSer); }
final SerializationConfig config = prov.getConfig(); BeanDescription beanDesc = config.introspect(origType); JsonSerializer<?> ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } else { // changes; assume static typing; plus, need to re-introspect if class differs staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); ser = _createSerializer2(prov, delegateType, beanDesc, true); return new StdDelegatingSerializer(conv, delegateType, ser);
@Override public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc) { Class<?> raw = type.getRawClass(); if (Range.class.isAssignableFrom(raw)) { return new RangeSerializer(_findDeclared(type, Range.class)); } if (Table.class.isAssignableFrom(raw)) { return new TableSerializer(_findDeclared(type, Table.class)); } // since 2.4 if (HostAndPort.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (InternetDomainName.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } // not sure how useful, but why not? if (CacheBuilderSpec.class.isAssignableFrom(raw) || CacheBuilder.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (HashCode.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (FluentIterable.class.isAssignableFrom(raw)) { JavaType iterableType = _findDeclared(type, Iterable.class); return new StdDelegatingSerializer(FluentConverter.instance, iterableType, null); } return super.findSerializer(config, type, beanDesc); }
/** * 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; }
@Override public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { Object delegateValue = convertValue(value); // should we accept nulls? if (delegateValue == null) { provider.defaultSerializeNull(jgen); return; } _delegateSerializer.serialize(delegateValue, jgen, provider); }
final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if (intr != null && prop != null) { 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()); if (existingSerializer == null && !delegateType.hasRawClass(Object.class)) { existingSerializer = provider.findValueSerializer(delegateType); return new StdDelegatingSerializer(conv, delegateType, existingSerializer);
/** * @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; }
Object ob = provider.getAttribute(CONVERTING_CONTENT_CONVERTER_LOCK); if (ob != null) { if (ob == Boolean.TRUE) { // just to ensure it's value we added. final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); if (intr != null && prop != null) { AnnotatedMember m = prop.getMember(); if (m != null) { provider.setAttribute(CONVERTING_CONTENT_CONVERTER_LOCK, Boolean.TRUE); Object convDef; try { convDef = intr.findSerializationContentConverter(m); } finally { provider.setAttribute(CONVERTING_CONTENT_CONVERTER_LOCK, null); JavaType delegateType = conv.getOutputType(provider.getTypeFactory()); if ((existingSerializer == null) && !delegateType.isJavaLangObject()) { existingSerializer = provider.findValueSerializer(delegateType); return new StdDelegatingSerializer(conv, delegateType, existingSerializer);
public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { // First: figure out what is the fully generic delegate type: TypeFactory tf = provider.getTypeFactory(); JavaType implType = tf.constructType(_converter.getClass()); JavaType[] params = tf.findTypeParameters(implType, Converter.class); if (params == null || params.length != 2) { throw new JsonMappingException("Could not determine Converter parameterization for " +implType); } // and then we can find serializer to delegate to, construct a new instance: JavaType delegateType = params[1]; return withDelegate(_converter, delegateType, provider.findValueSerializer(delegateType, property)); }
@Override public boolean isEmpty(SerializerProvider prov, Object value) { Object delegateValue = convertValue(value); if (delegateValue == null) { return true; } if (_delegateSerializer == null) { // best we can do for now, too costly to look up return (value == null); } return _delegateSerializer.isEmpty(prov, delegateValue); }
/** * Helper method that will check whether given annotated entity (usually class, * but may also be a property accessor) indicates that a {@link Converter} is to * be used; and if so, to construct and return suitable serializer for it. * If not, will simply return given serializer as is. */ protected JsonSerializer<?> findConvertingSerializer(SerializerProvider prov, Annotated a, JsonSerializer<?> ser) throws JsonMappingException { Converter<Object,Object> conv = findConverter(prov, a); if (conv == null) { return ser; } JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); return new StdDelegatingSerializer(conv, delegateType, ser); }
@Override public void serializeWithType(Object value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonProcessingException { /* 03-Oct-2012, tatu: This is actually unlikely to work ok... but for now, * let's give it a chance? */ Object delegateValue = convertValue(value); _delegateSerializer.serializeWithType(delegateValue, jgen, provider, typeSer); }
/** * Method used for creating resolved contextual instances. Must be * overridden when sub-classing. */ protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter, JavaType delegateType, JsonSerializer<?> delegateSerializer) { ClassUtil.verifyMustOverride(StdDelegatingSerializer.class, this, "withDelegate"); return new StdDelegatingSerializer(converter, delegateType, delegateSerializer); }
@Override public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { return super.createContextual(serializerProvider, property); } }
final SerializationConfig config = prov.getConfig(); BeanDescription beanDesc = config.introspect(origType); JsonSerializer<?> ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo()); } else { // changes; assume static typing; plus, need to re-introspect if class differs staticTyping = true; if (!type.hasRawClass(origType.getRawClass())) { beanDesc = config.introspect(type); return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping); JavaType delegateType = conv.getOutputType(prov.getTypeFactory()); if (!delegateType.hasRawClass(type.getRawClass())) { beanDesc = config.introspect(delegateType); ser = _createSerializer2(prov, delegateType, beanDesc, true); return new StdDelegatingSerializer(conv, delegateType, ser);
@Override public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc) { Class<?> raw = type.getRawClass(); if (Range.class.isAssignableFrom(raw)) { return new RangeSerializer(_findDeclared(type, Range.class)); } if (Table.class.isAssignableFrom(raw)) { return new TableSerializer(_findDeclared(type, Table.class)); } // since 2.4 if (HostAndPort.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (InternetDomainName.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } // not sure how useful, but why not? if (CacheBuilderSpec.class.isAssignableFrom(raw) || CacheBuilder.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (HashCode.class.isAssignableFrom(raw)) { return ToStringSerializer.instance; } if (FluentIterable.class.isAssignableFrom(raw)) { JavaType iterableType = _findDeclared(type, Iterable.class); return new StdDelegatingSerializer(FluentConverter.instance, iterableType, null); } return super.findSerializer(config, type, beanDesc); }
/** * 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; }