用于ValueObject层次结构的Jackson序列化器-多态 [英] Jackson serializer for ValueObject hierarchy - polymorphic

问题描述

作为> jackson-serialize-simple的延续一个没有嵌套的属性值对象枚举

我希望能够以非常简单的方式创建包装一个属性ValueObject，只需从基础ValueObject类继承即可.

I would like to be able to create Wrapping one attribute ValueObjects in a very simple manner, just by inheriting from base ValueObject class:

@JsonSerialize(using = ValueObjectJsonSerializer.class)
@EqualsAndHashCode
public abstract class BaseValueObject<T> { 

  T value;
  .......
}
// I want to be able to create multiple ValueObject wrapping Types like
public class Name extends ValueObject<String> {}
public class Surname extends ValueObject<String>{}
public class Age extends ValueObject<Integer>{} 
etc...

有可能吗?

正在实施

    public void serializeWithType(Object value, JsonGenerator gen, SerializerProvider serializers,
                              TypeSerializer typeSer) throws IOException

足够了，还是必须以其他方式完成?

sufficient for it, or it has to be done some other way?

在哪里可以找到一些简单的serializeWithType实现示例?

Where could I find some simple sample serializeWithType implementation?

也许基类应该重写一些返回实际类型描述符的方法?

Maybe base classes should overwrite some method returning actual type descriminator?

我还必须实现反序列化器才能反序列化此类json吗?

Do I also have to implement deserializer to be able deserialize such jsons?

推荐答案

下面的实现可以序列化多态类型，仍然保留反序列化器. 我不知道杰克逊如何序列化和反序列化Java枚举，而不必在json中包含它们的类型.这就是我感兴趣的.OnePropertyValueObject可以像枚举一样序列化和反序列化.

Below implementation can serialize polymorphic types, still deserializer remains. I wonder how jackson serializes and deserializes Java Enums that it doesn't have to include their type in json. This would be what I am interested in. OnePropertyValueObject could be serialized and deserialized like enum.

@Slf4j
class ValueObjectJsonSerializer extends JsonSerializer<Object> {
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (value == null) {
            gen.writeNull();
            return;
        }
        Class clazz = value.getClass();
        while (clazz != Object.class) {
            java.lang.reflect.Field[] fields = value.getClass().getDeclaredFields();
            if (fields.length > 1) {
                throw new IOException(
                    "Do not use this serializer for the class " + value.getClass().getSimpleName() + " which has at least " + fields.length +
                        " fields!");
            } else if (fields.length == 1) {

                final Field first = fields[0];
                try {
                    final Object fieldValue = first.get(value);
                    gen.writeObject(fieldValue);
                    log.info("field {} value: {}", fields[0], fieldValue);
                    return;
                } catch (IllegalAccessException e) {
                    throw new IOException(e);
                }
            } else {
                clazz = clazz.getSuperclass();
            }
        }

        throw new IOException(
            "Do not use this serializer for the class " + value.getClass().getSimpleName() + " which has no fields!");

    }

    public void serializeWithType(Object value, JsonGenerator gen, SerializerProvider serializers,
                                  TypeSerializer typeSer) throws IOException
    {
        if (value == null) {
            gen.writeNull();
            return;
        }
        Class clazz = value.getClass();
        while (clazz != Object.class) {
            java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
            if (fields.length > 1) {
                throw new IOException(
                    "Do not use this serializer for the class " + value.getClass().getSimpleName() + " which has at least " + fields.length + " fields!");
            } else if (fields.length == 1) {

                final Field first = fields[0];
                try {
                    final Object fieldValue = first.get(value);

                    WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
                        typeSer.typeId(value, value.getClass(), JsonToken.VALUE_STRING));
                    gen.writeObject(fieldValue);
                    typeSer.writeTypeSuffix(gen, typeIdDef);
                    log.info("field {} value: {}", fields[0], fieldValue);
                    return;
                } catch (IllegalAccessException e) {
                    throw new IOException(e);
                }
            } else {
                clazz = clazz.getSuperclass();
            }
        }

        throw new IOException(
            "Do not use this type serializer for the class " + value.getClass().getSimpleName() + " which has no fields!");
    }

    public JsonTypeInfo.As getTypeInclusion() {
        return JsonTypeInfo.As.WRAPPER_OBJECT;
    }
}

这篇关于用于ValueObject层次结构的Jackson序列化器-多态的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！