java - 某些环境中的 Gson SerializedName 更改

Question

我有一个带有一些 GSon 注释的 DTO。
我的问题是，如果我的应用程序在开发、暂存或生产中运行，这些注释的值必须改变...

目前，我必须用不同的值打包我的应用程序，我希望它是自动的...它在 Spring Boot 应用程序中，我想使用 spring.profiles.active 告诉我的应用程序采用正确的 serializedName

这是我使用的那种代码

  // Tests
  // @SerializedName("customfield_10123")
  // Prod
  @SerializedName("customfield_10114")
  private ActionDto action;

我希望有更好的方法吗？

Answer 1

这是一个非常粗略的例子，说明如何实现你想要的:

首先为每个可能的配置文件创建一个属性文件(名称可以是任何东西，但配置文件必须在名称上):

application-dev.properties
application-prod.properties
...

根据每个配置文件为每个键使用所需的值填充属性:

test=abc.test
...

注释您的 POJO:

public class Foo {

    @SerializedName("${test}")
    private String name;

    ...

}

为您的类创建一个自定义序列化程序，它将解释自定义名称，如下所示:

public class FooSerializer implements JsonSerializer<Foo> {

    private static final Pattern PATTERN = Pattern.compile("\\$\\{(.*)\\}");
    private static Properties props;

    static {
        try {
            Resource resource = new ClassPathResource(String.format("/application-%s.properties", System.getProperty("spring.profiles.active")));
            props = PropertiesLoaderUtils.loadProperties(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public JsonElement serialize(Foo foo, Type type, JsonSerializationContext jsonSerializationContext) {

        Field[] fields = foo.getClass().getDeclaredFields();

        JsonObject object = new JsonObject();

        for (Field field : fields) {
            field.setAccessible(true);
            String name = field.getName();
            if (field.isAnnotationPresent(SerializedName.class)) {
                String value = field.getAnnotation(SerializedName.class).value();
                Matcher matcher = PATTERN.matcher(value);
                if (matcher.find()) {
                    name = props.get(matcher.group(1)).toString();
                } else {
                    name = value;
                }
            }
            try {
                if (field.get(foo) != null) {
                    object.addProperty(name, field.get(foo).toString());
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return object;
    }
}

现在您只需要注册您的自定义序列化程序就可以了:

Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class, new FooSerializer()).setPrettyPrinting().create();

当然，根据 Activity 配置文件可能有更好的方法来恢复属性文件，但给定的片段应该足以让您继续。此外，您需要考虑在任何给定时间可能有多个配置文件处于 Activity 状态的事实，因此如果这是您的情况，您需要在恢复属性之前考虑到这一点。

如果您总是想使用属性中的值，您甚至不需要正则表达式部分。我使用正则表达式来允许这两种情况。

如果有什么不清楚的地方，请告诉我，我会尽力改进。

编辑:

对于反序列化，我想不出任何好的东西，所以这里有一个我认为远未成功但完成工作的例子:

功能接口(interface):

public interface Converter {

    Object convert(String s);
}

反序列化器:

public class FooDeserializer implements JsonDeserializer<Foo> {

    private static final Pattern PATTERN = Pattern.compile("\\$\\{(.*)\\}");
    private static Properties props;
    private static Map<Class, Converter> converterForClass = new HashMap<>();

    static {
        try {
            Resource resource = new ClassPathResource(String.format("/application-%s.properties", System.getProperty("spring.profiles.active")));
            props = PropertiesLoaderUtils.loadProperties(resource);

            converterForClass.put(Integer.TYPE, s -> Integer.parseInt(s.replace("\"", "")));
            converterForClass.put(Double.TYPE, s -> Double.parseDouble(s.replace("\"", "")));
            converterForClass.put(String.class, s -> s);
            converterForClass.put(Long.TYPE, s -> Long.parseLong(s.replace("\"", "")));
            converterForClass.put(Boolean.TYPE, s -> Boolean.parseBoolean(s.replace("\"", "")));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Foo deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {


        Foo foo = new Foo();

        JsonObject jobject = (JsonObject) jsonElement;

        for (Entry entry : jobject.entrySet()) {
            Field field = searchField(entry.getKey().toString());
            if (field != null) {
                field.setAccessible(true);
                try {
                    Object r = converterForClass.get(field.getType()).convert(entry.getValue().toString());
                    field.set(foo, r);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return foo;

    }

    private Field searchField(String name) {
        Field[] fields = Foo.class.getDeclaredFields();

        for (Field field : fields) {
            field.setAccessible(true);
            if (field.isAnnotationPresent(SerializedName.class)) {
                String value = field.getAnnotation(SerializedName.class).value();

                Matcher matcher = PATTERN.matcher(value);
                if (value.equals(name)) {
                    return field;
                } else if (matcher.find()) {
                    if (props.get(matcher.group(1)).equals(name)) {
                        return field;
                    }
                }
            } else {
                if (field.getName().equals(name)) {
                    return field;
                }
            }
        }

        return null;
    }

注册反序列化器:

gsonBuilder.registerTypeAdapter(Foo.class, new FooDeserializer());

上述方法的问题是它不适用于嵌套对象。您将不得不进行一些进一步的验证和实现。它还使用了 Java 8 的特性。