protected void _writeNullKeyedEntry(JsonGenerator gen, SerializerProvider provider, Object value) throws IOException { JsonSerializer<Object> keySerializer = provider.findNullKeySerializer(_keyType, _property); JsonSerializer<Object> valueSer; if (value == null) { if (_suppressNulls) { return; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, value); } if (_suppressableValue == MARKER_FOR_EMPTY) { if (valueSer.isEmpty(provider, value)) { return; } } else if ((_suppressableValue != null) && (_suppressableValue.equals(value))) { return; } } try { keySerializer.serialize(null, gen, provider); valueSer.serialize(value, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, ""); } }
/** * Method called to serialize fields, when the value type is statically known, so that value * serializer is passed and does not need to be fetched from provider. */ public void serializeFieldsUsing( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException { final JsonSerializer<Object> keySerializer = _keySerializer; final Set<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; for (Map.Entry<?, ?> entry : value.entrySet()) { Object keyElem = entry.getKey(); if (ignored != null && ignored.contains(keyElem)) continue; if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { keySerializer.serialize(keyElem, gen, provider); } final Object valueElem = entry.getValue(); if (valueElem == null) { provider.defaultSerializeNull(gen); } else { try { if (typeSer == null) { ser.serialize(valueElem, gen, provider); } else { ser.serializeWithType(valueElem, gen, provider, typeSer); } } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } } }
/** Serialization method called when exclusion filtering needs to be applied. */ public void serializeOptionalFields( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, suppressableValue); return; } final Set<String> ignored = _ignoredEntries; final boolean checkEmpty = (MARKER_FOR_EMPTY == suppressableValue); for (Map.Entry<?, ?> entry : value.entrySet()) { // First find key serializer final Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; } // Then value serializer final Object valueElem = entry.getValue(); JsonSerializer<Object> valueSer; if (valueElem == null) { if (_suppressNulls) { // all suppressions include null-suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, valueElem); } // also may need to skip non-empty values: if (checkEmpty) { if (valueSer.isEmpty(provider, valueElem)) { continue; } } else if (suppressableValue != null) { if (suppressableValue.equals(valueElem)) { continue; } } } // and then serialize, if all went well try { keySerializer.serialize(keyElem, gen, provider); valueSer.serialize(valueElem, gen, provider); } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } }
/** Method called to serialize fields, when the value type is not statically known. */ public void serializeFields(Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, jgen, provider); return; } final JsonSerializer<Object> keySerializer = _keySerializer; final HashSet<String> ignored = _ignoredEntries; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); PropertySerializerMap serializers = _dynamicValueSerializers; for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); // First, serialize key Object keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider); } else { // [JACKSON-314] skip entries with null values? if (skipNulls && valueElem == null) continue; // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, jgen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = valueElem.getClass(); JsonSerializer<Object> serializer = serializers.serializerFor(cc); if (serializer == null) { if (_valueType.hasGenericTypes()) { serializer = _findAndAddDynamic( serializers, provider.constructSpecializedType(_valueType, cc), provider); } else { serializer = _findAndAddDynamic(serializers, cc, provider); } serializers = _dynamicValueSerializers; } try { serializer.serialize(valueElem, jgen, provider); } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = "" + keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } }
public final void defaultSerializeNull(JsonGenerator gen) throws IOException { if (_stdNullValueSerializer) { // minor perf optimization gen.writeNull(); } else { _nullValueSerializer.serialize(null, gen, this); } }
/** * restore listenable future. * * @param identifierUris the identifierUris * @return the listenable future */ public ListenableFuture<Application> restore(java.util.List<String> identifierUris) { JsonSerializer serializer = getResolver().getJsonSerializer(); String serializedidentifierUris = serializer.serialize(identifierUris); ListenableFuture<String> future = restoreRaw(serializedidentifierUris); return transformToEntityListenableFuture(future, Application.class, getResolver()); }
/** * Convenience method that will serialize given value (which can be null) using standard * serializer locating functionality. It can be called for all values including field and Map * values, but usually field values are best handled calling {@link #defaultSerializeField} * instead. */ public final void defaultSerializeValue(Object value, JsonGenerator gen) throws IOException { if (value == null) { if (_stdNullValueSerializer) { // minor perf optimization gen.writeNull(); } else { _nullValueSerializer.serialize(null, gen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, gen, this); } }
/** * General-purpose serialization for contents, where we do not necessarily know the value * serialization, but we do know that no value suppression is needed (which simplifies processing * a bit) */ public void serializeFields(Map<?, ?> value, JsonGenerator gen, SerializerProvider provider) throws IOException { // If value type needs polymorphic type handling, some more work needed: if (_valueTypeSerializer != null) { serializeTypedFields(value, gen, provider, null); return; } final JsonSerializer<Object> keySerializer = _keySerializer; final Set<String> ignored = _ignoredEntries; Object keyElem = null; try { for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); // First, serialize key keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider); } else { // One twist: is entry ignorable? If so, skip if ((ignored != null) && ignored.contains(keyElem)) { continue; } keySerializer.serialize(keyElem, gen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(gen); continue; } JsonSerializer<Object> serializer = _valueSerializer; if (serializer == null) { serializer = _findSerializer(provider, valueElem); } serializer.serialize(valueElem, gen, provider); } } catch (Exception e) { // Add reference information wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } }
/** @since 2.5 */ public void serializeTypedFields( Map<?, ?> value, JsonGenerator gen, SerializerProvider provider, Object suppressableValue) // since 2.5 throws IOException { final Set<String> ignored = _ignoredEntries; final boolean checkEmpty = (MARKER_FOR_EMPTY == suppressableValue); for (Map.Entry<?, ?> entry : value.entrySet()) { Object keyElem = entry.getKey(); JsonSerializer<Object> keySerializer; if (keyElem == null) { keySerializer = provider.findNullKeySerializer(_keyType, _property); } else { // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer = _keySerializer; } final Object valueElem = entry.getValue(); // And then value JsonSerializer<Object> valueSer; if (valueElem == null) { if (_suppressNulls) { // all suppression include null suppression continue; } valueSer = provider.getDefaultNullValueSerializer(); } else { valueSer = _valueSerializer; if (valueSer == null) { valueSer = _findSerializer(provider, valueElem); } // also may need to skip non-empty values: if (checkEmpty) { if (valueSer.isEmpty(provider, valueElem)) { continue; } } else if (suppressableValue != null) { if (suppressableValue.equals(valueElem)) { continue; } } } keySerializer.serialize(keyElem, gen, provider); try { valueSer.serializeWithType(valueElem, gen, provider, _valueTypeSerializer); } catch (Exception e) { wrapAndThrow(provider, e, value, String.valueOf(keyElem)); } } }
@Override public byte[] fromConnectData(String topic, Schema schema, Object value) { JsonNode jsonValue = enableSchemas ? convertToJsonWithEnvelope(schema, value) : convertToJsonWithoutEnvelope(schema, value); try { return serializer.serialize(topic, jsonValue); } catch (SerializationException e) { throw new DataException( "Converting Kafka Connect data to byte[] failed due to serialization error: ", e); } }
/** Send out token in JSON. */ public static void sendToken(HttpServletResponse response, Map<String, String> token) { java.io.PrintWriter writer; sendJsonHeaders(response); try { writer = response.getWriter(); writer.write(JsonSerializer.serialize(token)); writer.flush(); writer.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
/** * Method called to serialize fields, when the value type is statically known, so that value * serializer is passed and does not need to be fetched from provider. */ protected void serializeFieldsUsing( Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser) throws IOException, JsonGenerationException { final JsonSerializer<Object> keySerializer = _keySerializer; final HashSet<String> ignored = _ignoredEntries; final TypeSerializer typeSer = _valueTypeSerializer; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); Object keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider); } else { // [JACKSON-314] also may need to skip entries with null values if (skipNulls && valueElem == null) continue; if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, jgen, provider); } if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { try { if (typeSer == null) { ser.serialize(valueElem, jgen, provider); } else { ser.serializeWithType(valueElem, jgen, provider, typeSer); } } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = "" + keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } }
protected void serializeTypedFields( Map<?, ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { final JsonSerializer<Object> keySerializer = _keySerializer; JsonSerializer<Object> prevValueSerializer = null; Class<?> prevValueClass = null; final HashSet<String> ignored = _ignoredEntries; final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES); for (Map.Entry<?, ?> entry : value.entrySet()) { Object valueElem = entry.getValue(); // First, serialize key Object keyElem = entry.getKey(); if (keyElem == null) { provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider); } else { // [JACKSON-314] also may need to skip entries with null values if (skipNulls && valueElem == null) continue; // One twist: is entry ignorable? If so, skip if (ignored != null && ignored.contains(keyElem)) continue; keySerializer.serialize(keyElem, jgen, provider); } // And then value if (valueElem == null) { provider.defaultSerializeNull(jgen); } else { Class<?> cc = valueElem.getClass(); JsonSerializer<Object> currSerializer; if (cc == prevValueClass) { currSerializer = prevValueSerializer; } else { currSerializer = provider.findValueSerializer(cc, _property); prevValueSerializer = currSerializer; prevValueClass = cc; } try { currSerializer.serializeWithType(valueElem, jgen, provider, _valueTypeSerializer); } catch (Exception e) { // [JACKSON-55] Need to add reference information String keyDesc = "" + keyElem; wrapAndThrow(provider, e, value, keyDesc); } } } }
/** objTypePair.getObject() must not be null */ @SuppressWarnings({"unchecked", "rawtypes"}) private JsonElement findAndInvokeCustomSerializer(ObjectTypePair objTypePair) { Pair<JsonSerializer<?>, ObjectTypePair> pair = objTypePair.getMatchingHandler(serializers); if (pair == null) { return null; } JsonSerializer serializer = pair.first; objTypePair = pair.second; start(objTypePair); try { JsonElement element = serializer.serialize(objTypePair.getObject(), objTypePair.getType(), context); return element == null ? JsonNull.createJsonNull() : element; } finally { end(objTypePair); } }
/** * The method to be called by {@link ObjectMapper} and {@link ObjectWriter} for serializing given * value, using serializers that this provider has access to (via caching and/or creating new * serializers as need be). */ public void serializeValue(JsonGenerator jgen, Object value) throws IOException, JsonGenerationException { JsonSerializer<Object> ser; final boolean wrap; if (value == null) { // no type provided; must just use the default null serializer ser = getDefaultNullValueSerializer(); wrap = false; // no name to use for wrapping; can't do! } else { Class<?> cls = value.getClass(); // true, since we do want to cache root-level typed serializers (ditto for null property) ser = findTypedValueSerializer(cls, true, null); // Ok: should we wrap result in an additional property ("root name")? String rootName = _config.getRootName(); if (rootName == null) { // not explicitly specified // [JACKSON-163] wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { jgen.writeStartObject(); jgen.writeFieldName(_rootNames.findRootName(value.getClass(), _config)); } } else if (rootName.length() == 0) { wrap = false; } else { // [JACKSON-764] // empty String means explicitly disabled; non-empty that it is enabled wrap = true; jgen.writeStartObject(); jgen.writeFieldName(rootName); } } try { ser.serialize(value, jgen, this); if (wrap) { jgen.writeEndObject(); } } catch (IOException ioe) { // As per [JACKSON-99], pass IOException and subtypes as-is throw ioe; } catch (Exception e) { // but wrap RuntimeExceptions, to get path information String msg = e.getMessage(); if (msg == null) { msg = "[no message for " + e.getClass().getName() + "]"; } throw new JsonMappingException(msg, e); } }
/** * Convenience method that will serialize given field with specified value. Value may be null. * Serializer is done using the usual null) using standard serializer locating functionality. */ public final void defaultSerializeField(String fieldName, Object value, JsonGenerator gen) throws IOException { gen.writeFieldName(fieldName); if (value == null) { /* Note: can't easily check for suppression at this point * any more; caller must check it. */ if (_stdNullValueSerializer) { // minor perf optimization gen.writeNull(); } else { _nullValueSerializer.serialize(null, gen, this); } } else { Class<?> cls = value.getClass(); findTypedValueSerializer(cls, true, null).serialize(value, gen, this); } }
public final void write(JsonWriter jsonwriter, Object obj) { if (a == null) { a().write(jsonwriter, obj); return; } if (obj == null) { jsonwriter.nullValue(); return; } else { Streams.write(a.serialize(obj, d.getType(), c.serializationContext), jsonwriter); return; } }
private final void serializeUsingCustom( List<String> value, JsonGenerator jgen, SerializerProvider provider, int len) throws IOException, JsonGenerationException { int i = 0; try { final JsonSerializer<String> ser = _serializer; for (i = 0; i < len; ++i) { String str = value.get(i); if (str == null) { provider.defaultSerializeNull(jgen); } else { ser.serialize(str, jgen, provider); } } } catch (Exception e) { wrapAndThrow(provider, e, value, i); } }
@Override public void serialize(Optional<?> opt, JsonGenerator gen, SerializerProvider provider) throws IOException { if (!opt.isPresent()) { // 22-Oct-2015, tatu: With unwrapping we can not serialize value, just key/value pairs so: if (_unwrapper == null) { provider.defaultSerializeNull(gen); } return; } Object value = opt.get(); JsonSerializer<Object> ser = _valueSerializer; if (ser == null) { ser = _findCachedSerializer(provider, value.getClass()); } if (_valueTypeSerializer != null) { ser.serializeWithType(value, gen, provider, _valueTypeSerializer); } else { ser.serialize(value, gen, provider); } }
/** * The method to be called by {@link ObjectWriter} for serializing given value (assumed to be of * specified root type, instead of runtime type of value), when it may know specific {@link * JsonSerializer} to use. * * @param rootType Type to use for locating serializer to use, instead of actual runtime type, if * no serializer is passed * @param ser Root Serializer to use, if not null * @since 2.1 */ public void serializeValue( JsonGenerator jgen, Object value, JavaType rootType, JsonSerializer<Object> ser) throws IOException, JsonGenerationException { final boolean wrap; if (value == null) { ser = getDefaultNullValueSerializer(); wrap = false; } else { // Let's ensure types are compatible at this point if (rootType != null) { if (!rootType.getRawClass().isAssignableFrom(value.getClass())) { _reportIncompatibleRootType(value, rootType); } } // root value, not reached via property: if (ser == null) { ser = findTypedValueSerializer(rootType, true, null); } wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE); if (wrap) { jgen.writeStartObject(); jgen.writeFieldName(_rootNames.findRootName(rootType, _config)); } } try { ser.serialize(value, jgen, this); if (wrap) { jgen.writeEndObject(); } } catch (IOException ioe) { // no wrapping for IO (and derived) throw ioe; } catch (Exception e) { // but others do need to be, to get path etc String msg = e.getMessage(); if (msg == null) { msg = "[no message for " + e.getClass().getName() + "]"; } throw new JsonMappingException(msg, e); } }