下面列出了com.fasterxml.jackson.databind.ser.impl.ObjectIdWriter#com.fasterxml.jackson.core.type.WritableTypeId 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@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(Object bean, JsonGenerator gen,
SerializerProvider provider, TypeSerializer typeSer)
throws IOException
{
if (_objectIdWriter != null) {
gen.setCurrentValue(bean); // [databind#631]
_serializeWithObjectId(bean, gen, provider, typeSer);
return;
}
gen.setCurrentValue(bean); // [databind#631]
WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_OBJECT);
typeSer.writeTypePrefix(gen, typeIdDef);
if (_propertyFilterId != null) {
serializeFieldsFiltered(bean, gen, provider);
} else {
serializeFields(bean, gen, provider);
}
typeSer.writeTypeSuffix(gen, typeIdDef);
}
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);
}
@Override
public void serializeWithType(byte[] value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
// most likely scalar
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
g.writeBinary(provider.getConfig().getBase64Variant(),
value, 0, value.length);
typeSer.writeTypeSuffix(g, typeIdDef);
/* OLD impl
typeSer.writeTypePrefixForScalar(value, g);
g.writeBinary(provider.getConfig().getBase64Variant(),
value, 0, value.length);
typeSer.writeTypeSuffixForScalar(value, g);
*/
}
@Override
public void serializeWithType(char[] value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
// [JACKSON-289] allows serializing as 'sparse' char array too:
final boolean asArray = provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS);
WritableTypeId typeIdDef;
if (asArray) {
typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.START_ARRAY));
_writeArrayContents(g, value);
} else { // default is to write as simple String
typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_STRING));
g.writeString(value, 0, value.length);
}
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(Object bean, JsonGenerator gen,
SerializerProvider provider, TypeSerializer typeSer)
throws IOException
{
/* 10-Dec-2014, tatu: Not sure if this can be made to work reliably;
* but for sure delegating to default implementation will not work. So:
*/
if (_objectIdWriter != null) {
_serializeWithObjectId(bean, gen, provider, typeSer);
return;
}
gen.setCurrentValue(bean);
WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_ARRAY);
typeSer.writeTypePrefix(gen, typeIdDef);
serializeAsArray(bean, gen, provider);
typeSer.writeTypeSuffix(gen, typeIdDef);
}
@Override
public void serializeWithType(JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
@SuppressWarnings("deprecation")
boolean trimEmptyArray = (provider != null) &&
!provider.isEnabled(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS);
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(this, JsonToken.START_OBJECT));
for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
BaseJsonNode value = (BaseJsonNode) en.getValue();
// check if WRITE_EMPTY_JSON_ARRAYS feature is disabled,
// if the feature is disabled, then should not write an empty array
// to the output, so continue to the next element in the iteration
if (trimEmptyArray && value.isArray() && value.isEmpty(provider)) {
continue;
}
g.writeFieldName(en.getKey());
value.serialize(g, provider);
}
typeSer.writeTypeSuffix(g, typeIdDef);
}
@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(
CharIterable value,
JsonGenerator g,
SerializerProvider ctxt,
TypeSerializer typeSer
) throws IOException {
g.setCurrentValue(value);
WritableTypeId typeIdDef;
if (ctxt.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
typeIdDef = typeSer.writeTypePrefix(g, ctxt, typeSer.typeId(value, JsonToken.START_ARRAY));
writeContentsAsArray(value, g);
} else {
typeIdDef = typeSer.writeTypePrefix(g, ctxt, typeSer.typeId(value, JsonToken.VALUE_STRING));
char[] chars = value.toArray();
g.writeString(chars, 0, chars.length);
}
typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
@Override
public void serializeWithType(LocalDateTime 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 {
DateTimeFormatter dtf = _formatter;
if (dtf == null) {
dtf = _defaultFormatter();
}
g.writeString(value.format(dtf));
}
typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
@Override
public void serializeWithType(LocalTime 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 {
DateTimeFormatter dtf = _formatter;
if (dtf == null) {
dtf = _defaultFormatter();
}
g.writeString(value.format(dtf));
}
typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
@Override
public void serializeWithType(LocalDate 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
switch (typeIdDef.valueShape) {
case START_ARRAY:
_serializeAsArrayContents(value, g, ctxt);
break;
case VALUE_NUMBER_INT:
g.writeNumber(value.toEpochDay());
break;
default:
g.writeString((_formatter == null) ? value.toString() : value.format(_formatter));
}
typeSer.writeTypeSuffix(g, ctxt, 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);
}
@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 void serializeWithType(BinaryArg value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException {
WritableTypeId typeId = typeSer.typeId(value, START_OBJECT);
typeSer.writeTypePrefix(gen, typeId);
serialize(value, gen, provider);
typeSer.writeTypeSuffix(gen, typeId);
}
/**
* Factory method for constructing type id value object to pass to
* {@link #writeTypePrefix}.
*/
public WritableTypeId typeId(Object value, JsonToken valueShape) {
WritableTypeId typeIdDef = new WritableTypeId(value, valueShape);
switch (getTypeInclusion()) {
case EXISTING_PROPERTY:
typeIdDef.include = WritableTypeId.Inclusion.PAYLOAD_PROPERTY;
typeIdDef.asProperty = getPropertyName();
break;
case EXTERNAL_PROPERTY:
typeIdDef.include = WritableTypeId.Inclusion.PARENT_PROPERTY;
typeIdDef.asProperty = getPropertyName();
break;
case PROPERTY:
typeIdDef.include = WritableTypeId.Inclusion.METADATA_PROPERTY;
typeIdDef.asProperty = getPropertyName();
break;
case WRAPPER_ARRAY:
typeIdDef.include = WritableTypeId.Inclusion.WRAPPER_ARRAY;
break;
case WRAPPER_OBJECT:
typeIdDef.include = WritableTypeId.Inclusion.WRAPPER_OBJECT;
break;
default:
VersionUtil.throwInternal();
}
return typeIdDef;
}
/**
* Helper method needed for backwards compatibility: since original type id
* can not be routed through completely, we have to reverse-engineer likely
* setting before calling suffix.
*
* @since 2.9
*/
protected final void _writeLegacySuffix(JsonGenerator g,
WritableTypeId typeId) throws IOException
{
// most likely logic within generator is this:
typeId.wrapperWritten = !g.canWriteTypeId();
writeTypeSuffix(g, typeId);
}
@Override
public WritableTypeId writeTypePrefix(JsonGenerator g,
WritableTypeId idMetadata) throws IOException
{
_generateTypeId(idMetadata);
return g.writeTypePrefix(idMetadata);
}
/**
* Helper method that will generate type id to use, if not already passed.
*
* @since 2.9
*/
protected void _generateTypeId(WritableTypeId idMetadata) {
Object id = idMetadata.id;
if (id == null) {
final Object value = idMetadata.forValue;
Class<?> typeForId = idMetadata.forValueType;
if (typeForId == null) {
id = idFromValue(value);
} else {
id = idFromValueAndType(value, typeForId);
}
idMetadata.id = id;
}
}
/**
* Implementing typed output for contents of a TokenBuffer is very tricky,
* since we do not know for sure what its contents might look like (or, rather,
* we do know when serializing, but not necessarily when deserializing!)
* One possibility would be to check the current token, and use that to
* determine if we would output JSON Array, Object or scalar value.
*<p>
* Note that we just claim it is scalar; this should work ok and is simpler
* than doing introspection on both serialization and deserialization.
*/
@Override
public final void serializeWithType(TokenBuffer value, JsonGenerator g,
SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
// 28-Jun-2017, tatu: As per javadoc, not sure what to report as likely shape. Could
// even look into first actual token inside... but, for now let's keep it simple
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(Object bean, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer0) throws IOException
{
// Regardless of other parts, first need to find value to serialize:
Object value = null;
try {
value = _accessor.getValue(bean);
// and if we got null, can also just write it directly
if (value == null) {
provider.defaultSerializeNull(gen);
return;
}
JsonSerializer<Object> ser = _valueSerializer;
if (ser == null) { // no serializer yet? Need to fetch
ser = provider.findValueSerializer(value.getClass(), _property);
} else {
// 09-Dec-2010, tatu: To work around natural type's refusal to add type info, we do
// this (note: type is for the wrapper type, not enclosed value!)
if (_forceTypeInformation) {
// Confusing? Type id is for POJO and NOT for value returned by JsonValue accessor...
WritableTypeId typeIdDef = typeSer0.writeTypePrefix(gen,
typeSer0.typeId(bean, JsonToken.VALUE_STRING));
ser.serialize(value, gen, provider);
typeSer0.writeTypeSuffix(gen, typeIdDef);
return;
}
}
// 28-Sep-2016, tatu: As per [databind#1385], we do need to do some juggling
// to use different Object for type id (logical type) and actual serialization
// (delegat type).
TypeSerializerRerouter rr = new TypeSerializerRerouter(typeSer0, bean);
ser.serializeWithType(value, gen, provider, rr);
} catch (Exception e) {
wrapAndThrow(provider, e, bean, _accessor.getName() + "()");
}
}
@Override // since 2.9
public WritableTypeId writeTypePrefix(JsonGenerator g,
WritableTypeId typeId) throws IOException {
// 28-Jun-2017, tatu: Important! Need to "override" value
typeId.forValue = _forObject;
return _typeSerializer.writeTypePrefix(g, typeId);
}
@Override
public void serializeWithType(InetAddress value, JsonGenerator g,
SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
// Better ensure we don't use specific sub-classes...
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, InetAddress.class, JsonToken.VALUE_STRING));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(TimeZone value, JsonGenerator g,
SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
// Better ensure we don't use specific sub-classes:
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, TimeZone.class, JsonToken.VALUE_STRING));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
/**
* Default implementation will write type prefix, call regular serialization
* method (since assumption is that value itself does not need JSON
* Array or Object start/end markers), and then write type suffix.
* This should work for most cases; some sub-classes may want to
* change this behavior.
*/
@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
// NOTE: need not really be string; just indicates "scalar of some kind"
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_STRING));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(InetSocketAddress value, JsonGenerator g,
SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
// Better ensure we don't use specific sub-classes...
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, InetSocketAddress.class, JsonToken.VALUE_STRING));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
/**
* Default implementation will write type prefix, call regular serialization
* method (since assumption is that value itself does not need JSON
* Array or Object start/end markers), and then write type suffix.
* This should work for most cases; some sub-classes may want to
* change this behavior.
*/
@Override
public void serializeWithType(Object value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_STRING));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
// [databind#631]: Assign current value, to be accessible by custom serializers
g.setCurrentValue(value);
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.START_ARRAY));
serializeContents(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public final void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
// [databind#631]: Assign current value, to be accessible by custom serializers
g.setCurrentValue(value);
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.START_ARRAY));
serializeContents(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
serialize(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}