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 public final void serialize(JsonGenerator gen, SerializerProvider ctxt) throws IOException { if (_value == null) { ctxt.defaultSerializeNull(gen); } else if (_value instanceof JsonSerializable) { ((JsonSerializable) _value).serialize(gen, ctxt); } else { // 25-May-2018, tatu: [databind#1991] do not call via generator but through context; // this to preserve contextual information ctxt.defaultSerializeValue(_value, gen); } }
final AnnotationIntrospector intr = provider.getAnnotationIntrospector(); final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember(); Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); serDef = intr.findContentSerializer(propertyAcc); if (serDef != null) { ser = provider.serializerInstance(propertyAcc, serDef); if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) { ser = provider.findValueSerializer(_valueType, property); keySer = provider.findKeySerializer(_keyType, property); } else { keySer = provider.handleSecondaryContextualization(keySer, property); boolean suppressNulls = _suppressNulls; if (property != null) { JsonInclude.Value inclV = property.findPropertyInclusion(provider.getConfig(), null); if (inclV != null) { JsonInclude.Include incl = inclV.getContentInclusion(); break; case CUSTOM: valueToSuppress = provider.includeFilterInstance(null, inclV.getContentFilter()); if (valueToSuppress == null) { // is this legal? suppressNulls = true;
/** * @since 2.8 */ protected JsonInclude.Value findIncludeOverrides(SerializerProvider provider, BeanProperty prop, Class<?> typeForDefaults) { if (prop != null) { return prop.findPropertyInclusion(provider.getConfig(), typeForDefaults); } // even without property or AnnotationIntrospector, may have type-specific defaults return provider.getDefaultPropertyInclusion(typeForDefaults); }
/** * Helper method that may be used to find if this deserializer has specific * {@link JsonFormat} settings, either via property, or through type-specific * defaulting. * * @param typeForDefaults Type (erased) used for finding default format settings, if any * * @since 2.7 */ protected JsonFormat.Value findFormatOverrides(SerializerProvider provider, BeanProperty prop, Class<?> typeForDefaults) { if (prop != null) { return prop.findPropertyFormat(provider.getConfig(), typeForDefaults); } // even without property or AnnotationIntrospector, may have type-specific defaults return provider.getDefaultPropertyFormat(typeForDefaults); }
jgen.writeStartArray(); double d; jgen.writeStartObject(); jgen.writeFieldName(columnNames[i]); switch (columnTypes[i]) { provider.defaultSerializeDateValue(rs.getDate(i + 1), jgen); break; provider.defaultSerializeDateValue(rs.getTime(i + 1), jgen); break; provider.defaultSerializeValue(blob.getBinaryStream(), jgen); blob.free(); break; provider.defaultSerializeValue(clob.getCharacterStream(), jgen); clob.free(); break; provider.defaultSerializeValue(rs.getObject(i + 1), jgen); break;
@Override public void serialize( ApiResponses value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { if (value != null && value.getExtensions() != null && !value.getExtensions().isEmpty()) { jgen.writeStartObject(); if (!value.isEmpty()) { for (String key: value.keySet()) { jgen.writeObjectField(key , value.get(key)); } } for (String ext: value.getExtensions().keySet()) { jgen.writeObjectField(ext , value.getExtensions().get(ext)); } jgen.writeEndObject(); } else { provider.defaultSerializeValue(value, jgen); } } }
@Override public void serialize(char[] value, JsonGenerator g, SerializerProvider provider) throws IOException { // [JACKSON-289] allows serializing as 'sparse' char array too: if (provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) { g.writeStartArray(value.length); g.setCurrentValue(value); _writeArrayContents(g, value); g.writeEndArray(); } else { g.writeString(value, 0, value.length); } }
@Override public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException { // 27-Nov-2009, tatu: As per [JACKSON-201] may or may not fail... if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) { failForEmpty(provider, value); } // But if it's fine, we'll just output empty JSON Object: gen.writeStartObject(); gen.writeEndObject(); }
@Override public void serialize(TargetAware value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { if (!unwrapping) { jgen.writeStartObject(); } provider.// findValueSerializer(ProjectionResource.class, null).// unwrappingSerializer(null).// serialize(toResource(value), jgen, provider); if (!unwrapping) { jgen.writeEndObject(); } }
@Override public void serialize(Resources value, JsonGenerator jgen, SerializerProvider provider) throws IOException { final SerializationConfig config = provider.getConfig(); JavaType javaType = config.constructType(value.getClass()); JsonSerializer<Object> serializer = BeanSerializerFactory.instance.createSerializer(provider, javaType); jgen.writeStartObject(); serializer.serialize(value, jgen, provider); jgen.writeEndObject(); }
/** * Method that will handle serialization of Date(-like) values, using * {@link SerializationConfig} settings to determine expected serialization * behavior. * Note: date here means "full" date, that is, date AND time, as per * Java convention (and not date-only values like in SQL) */ public final void defaultSerializeDateValue(Date date, JsonGenerator gen) throws IOException { if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) { gen.writeNumber(date.getTime()); } else { gen.writeString(_dateFormat().format(date)); } }
provider.findNullKeySerializer(_type.getKeyType(), _property) .serialize(null, gen, provider); } else { _keySerializer.serialize(key, gen, provider); gen.writeStartArray(); for (Object vv : entry.getValue()) { if (vv == null) { provider.defaultSerializeNull(gen); continue; if (valueSer == null) { Class<?> cc = vv.getClass(); valueSer = serializers.serializerFor(cc); if (valueSer == null) { valueSer = _findAndAddDynamic(serializers, cc, provider); valueSer.serialize(vv, gen, provider); } else { valueSer.serializeWithType(vv, gen, provider, _valueTypeSerializer); gen.writeEndArray();
@Override public void serialize(Integer value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (value != null && value == Integer.MAX_VALUE && provider.getAttribute(BOUND_SERIALIZER_AS_NUMBER) == null) { jgen.writeString(UNBOUNDED); } else { jgen.writeNumber(value); } } }
private final void serializeContents(List<String> value, JsonGenerator g, SerializerProvider provider, int len) throws IOException { g.setCurrentValue(value); int i = 0; try { for (; i < len; ++i) { String str = value.get(i); if (str == null) { provider.defaultSerializeNull(g); } else { g.writeString(str); } } } catch (Exception e) { wrapAndThrow(provider, e, value, i); } } }
private final void serializeContents(Collection<String> value, JsonGenerator g, SerializerProvider provider) throws IOException { int i = 0; try { for (String str : value) { if (str == null) { provider.defaultSerializeNull(g); } else { g.writeString(str); } ++i; } } catch (Exception e) { wrapAndThrow(provider, e, value, i); } } }
@Override public void serialize(Ref value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { Object obj = value.getValue(); if (obj != null) { // writeObject() abandons the serialization context and breaks @JsonView //jgen.writeObject(obj); // Tatu says that this is better: provider.defaultSerializeValue(value.getValue(), jgen); } else { jgen.writeString(value.key().getString()); } } }
public class JacksonIdToUrlSerializer extends JsonSerializer<String>{ @Override public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { UriInfo uriInfo = (UriInfo)provider.getAttribute("JerseyUriInfo"); jgen.writeString(uriInfo.getRequestUriBuilder().path(value).build().toString()); } }
/** * Method that will handle serialization of Dates used as {@link java.util.Map} keys, * based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS} * value (and if using textual representation, configured date format) */ public void defaultSerializeDateKey(Date date, JsonGenerator gen) throws IOException { if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) { gen.writeFieldName(String.valueOf(date.getTime())); } else { gen.writeFieldName(_dateFormat().format(date)); } }
protected void _serializeDynamicContents(Iterator<?> value, JsonGenerator g, SerializerProvider provider) throws IOException { final TypeSerializer typeSer = _valueTypeSerializer; PropertySerializerMap serializers = _dynamicSerializers; do { Object elem = value.next(); if (elem == null) { provider.defaultSerializeNull(g); continue; } Class<?> cc = elem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { if (_elementType.hasGenericTypes()) { serializer = _findAndAddDynamic(serializers, provider.constructSpecializedType(_elementType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicSerializers; } if (typeSer == null) { serializer.serialize(elem, g, provider); } else { serializer.serializeWithType(elem, g, provider, typeSer); } } while (value.hasNext()); } }