Question

是否有一种方法告诉Gson使用字符串值本身，而不是Java常量名称？理想情况下，在Gson配置中是全局的，因此它将对所有枚举都适用。

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class Main {
  public static class Dress {
    public Color color;
  }

  public static enum Color {
    RED("red"),
    BLUE("blue");

    private final String type;
    Color(final String type) { this.type = type; }

    public String toString() { return type; }
  }

  public static void main(String[] args) throws InterruptedException {
    Dress dress = new Dress();
    dress.color = Color.RED;

    GsonBuilder builder = new GsonBuilder();
    builder.setPrettyPrinting();
    Gson gson = builder.create();
    System.out.println(gson.toJson(dress));
    // ==> { "color": "RED" }
  }
}

它打印{ "color": "RED" }而不是{ "color": "red" }。

Answer 1

使用@SerializedName和序列化值

import com.google.gson.annotations.SerializedName;

public static enum Color {
    @SerializedName("red")
    RED("red"),
    @SerializedName("blue")
    BLUE("blue");
    ...
}

另一种方法是使用自定义序列化器

class ColorSerializer implements JsonSerializer {
   @Override
   public JsonElement serialize(Color src, Type typeOfSrc, JsonSerializationContext context) {
      return new JsonPrimitive(src.toString());
   }
}

然后在构建器中注册自定义序列化器

builder.registerTypeAdapter(Color.class, new ColorSerializer());

Answer 2

创建一个自定义序列化器，例如：

public class EnumSerializer<T extends Enum<T>>
                    implements JsonSerializer<T> {
    @Override
    public JsonElement serialize(T src, Type typeOfSrc,
                JsonSerializationContext context) {
        return new JsonPrimitive(src.toString());
    }
}

注册方式如下：

builder.registerTypeAdapter(Color.class, new EnumSerializer<>());
// there is a reason for generics: that way you can easily register it to 
// other Enum types also, for example:
// builder.registerTypeAdapter(SomeEnum.class, new EnumSerializer<>());

如果需要将其应用于一个或多个Enum，并且不想将其分别注册到每个Enum，则可以使用TypeAdapterFactory（稍微复杂一点）。首先，您需要TypeAdapter：

public class EnumTypeAdapter<T extends Enum<T>> extends TypeAdapter<T> {
    @Override
    public void write(JsonWriter out, T value) throws IOException {
        out.jsonValue(value.toString());
    }
    @Override
    public T read(JsonReader in) throws IOException {
        return null;
    }
}

然后是工厂：

public static class EnumTypeAdapterFactory implements TypeAdapterFactory {
    @Override
    // Actually it might be easier to just make EnumTypeAdapter non-generic
    // but on the other hand it might be better if used in some other contexts
    // and in some other ways. Thus these suppressions
    @SuppressWarnings({"rawtypes", "unchecked"})
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        // This if applies to all Enums. Change if not wanted.            
        if(Enum.class.isAssignableFrom(type.getRawType())) {
            return new EnumTypeAdapter();
        } else {
            return  null;                
        }
    }
}

并注册：

builder.registerTypeAdapterFactory(new EnumTypeAdapterFactory());

使Gson使用Enum字符串值而不是常量名称

2 个答案: