问题:

我有一堆结构如下的 DTO:

public class Foobar {
    private String name;
    private Timestamp time1;
    private Timestamp time2;
    private int value;
}

我需要将 Timestamps 序列化为两个独立的值(一次调用 .toString() 一次根据 ISO 标准格式化) 以便与旧 API 向后兼容，并从现在开始支持合适的时间格式。

所以 Foobar 的 JSON 输出应该是这样的:

{
    "name":"<some name>",
    "time1":"<some non standard time>",
    "iso_time1":"<ISO formatted time>",
    "time2":"<some non standard time>",
    "iso_time2":"<ISO formatted time>",
    "value":<some number>
}

由于现有代码，我只能使用 Gson。

问题:

是否有可能以通用方式执行此操作，这将适用于我所有的 DTO 而无需更改 DTO？

我想避免为每个现有的 DTO 编写 TypeAdapter/Serializer/new DTO。

我尝试了什么

类型适配器

我已经尝试通过 TypeAdapter 和 TypeAdapterFactory 来做到这一点，但我需要类的字段名称来区分这两个时间戳。

write(...) 方法说明了我遇到的问题(T extends Timestamp):

@Override
public void write(final JsonWriter out, final T value) throws IOException {
    out.value(value.toString());
    out.name(TIMESTAMP_ISO_PREFIX + fieldName).value(toISOFormat(value));
}

这里的问题是，我没有找到任何获取字段名称的方法。我试图用 TypeAdapterFactory 获取它，但工厂也不知道字段名称。

JsonSerializer

我也尝试通过 JsonSerializer 来实现，但是不可能返回两个 JSON 元素并且返回 JsonObject 会破坏现有的 API。

最佳答案

方法 1:使用 JsonSerialiser

您可以为您的对象创建一个 JsonSerialiser(即比 Timestamp 高一级)并根据需要使用它来附加额外的字段:

/**
 * Appends extra fields containing ISO formatted times for all Timestamp properties of an Object.
 */
class TimestampSerializer implements JsonSerializer<Object> {
    private Gson gson = new GsonBuilder().create();

    @Override
    public JsonElement serialize(Object src, Type typeOfSrc, JsonSerializationContext context) {
        JsonElement tree = gson.toJsonTree(src);
        if (tree instanceof JsonObject) {
            appendIsoTimestamps(src, (JsonObject) tree);
        }
        return tree;
    }

    private JsonObject appendIsoTimestamps(Object src, JsonObject object) {
        try {
            PropertyDescriptor[] descriptors = Introspector.getBeanInfo(src.getClass()).getPropertyDescriptors();
            for (PropertyDescriptor descriptor : descriptors) {
                if (descriptor.getPropertyType().equals(Timestamp.class)) {
                    Timestamp ts = (Timestamp) descriptor.getReadMethod().invoke(src);
                    object.addProperty("iso_" + descriptor.getName(), ts.toInstant().toString());
                }
            }
            return object;
        } catch (IllegalAccessException | InvocationTargetException | IntrospectionException e) {
            throw new JsonIOException(e);
        }
    }

示例用法:

public class GsonSerialiserTest {
    public static void main(String[] args) {
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Foobar.class, new TimestampSerializer());
        Gson gson = builder.create();
        Foobar baz = new Foobar("baz", 1, new Timestamp(System.currentTimeMillis()));
        System.out.println(gson.toJson(baz));
    }
}

一些注意事项:

• 此示例使用 java bean 内省(introspection)器查找 Timestamp 属性。它依赖于 getter 方法的存在。如果您没有 getter，则必须使用其他方法来读取时间戳属性。
• 序列化器委托(delegate)给另一个 gson 构建器(它不能调用 JsonSerializationContext 中的构建器，否则它最终会递归地调用自己)。如果您现有的序列化依赖于构建器中的其他工具，您必须连接一个单独的构建器并将其传递给序列化器。

如果你想对你正在序列化的所有对象执行此操作，请为整个 Object 层次结构注册适配器:

builder.registerTypeHierarchyAdapter(Object.class, typeAdapter);

如果您只想修改 DTO 的一个子集，您可以动态注册它们。 Reflections图书馆使这变得容易:

TimestampSerializer typeAdapter = new TimestampSerializer();

Reflections reflections = new Reflections(new ConfigurationBuilder()
    .setScanners(new SubTypesScanner(false))
    .setUrls(ClasspathHelper.forClassLoader(ClasspathHelper.contextClassLoader()))
    .filterInputsBy(new FilterBuilder().includePackage("com.package.dto", "com.package.other")));

Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);

for (Class<?> type : classes) {
    builder.registerTypeAdapter(type, typeAdapter);
}

上面的示例注册了命名包中的所有内容。如果您的 DTO 符合命名模式或实现通用接口(interface)/具有通用注释，您可以进一步限制注册的内容。

方法二:注册一个TypeAdapterFactory

TypeAdapters 在读取器/写入器级别工作，需要做更多的工作才能实现，但它们为您提供了更多控制权。

向构建器注册一个 TypeAdapterFactory 将允许您控制要编辑的类型。此示例将适配器应用于所有类型:

public static void main(String[] args) {
    GsonBuilder builder = new GsonBuilder();

    builder.registerTypeAdapterFactory(new TypeAdapterFactory() {
        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
            // Return null here if you don't want to handle the type.
            // This example returns an adapter for every type.
            return new TimestampAdapter<>(type);
        }
    });

    Gson gson = builder.create();
    Foobar baz = new Foobar("baz", 1);
    String json = gson.toJson(baz);
    System.out.println(json);
    System.out.println(gson.fromJson(json, Foobar.class));
}

还有适配器...

class TimestampAdapter<T> extends TypeAdapter<T> {
    private TypeToken<T> type;
    private Gson gson = new GsonBuilder().create();

    public TimestampAdapter(TypeToken<T> type) {
        this.type = type;
    }

    @Override
    public void write(JsonWriter out, T value) throws IOException {
        JsonObject object = appendIsoTimestamps(value, (JsonObject) gson.toJsonTree(value));
        TypeAdapters.JSON_ELEMENT.write(out, object);
    }

    private JsonObject appendIsoTimestamps(T src, JsonObject tree) {
        try {
            PropertyDescriptor[] descriptors = Introspector.getBeanInfo(src.getClass()).getPropertyDescriptors();
            for (PropertyDescriptor descriptor : descriptors) {
                if (descriptor.getPropertyType().equals(Timestamp.class)) {
                    Timestamp ts = (Timestamp) descriptor.getReadMethod().invoke(src);
                    tree.addProperty("iso_" + descriptor.getName(), ts.toInstant().toString());
                }
            }
            return tree;
        } catch (IllegalAccessException | InvocationTargetException | IntrospectionException e) {
            throw new JsonIOException(e);
        }
    }

    @Override
    public T read(JsonReader in) {
        return gson.fromJson(in, type.getType());
    }
}

关于java - 从一个 Java 字段写入两个 JSON 条目，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47870944/