Java 使用GSON解析JSON时使用枚举

这与我先前在这里提出的一个问题有关

我正在尝试解析相同的JSON，但现在我稍微更改了我的类

{
    "lower": 20,
    "upper": 40,
    "delimiter": " ",
    "scope": ["${title}"]
}

我的班级现在看起来像：

public class TruncateElement {

   private int lower;
   private int upper;
   private String delimiter;
   private List<AttributeScope> scope;

   // getters and setters
}


public enum AttributeScope {

    TITLE("${title}"),
    DESCRIPTION("${description}"),

    private String scope;

    AttributeScope(String scope) {
        this.scope = scope;
    }

    public String getScope() {
        return this.scope;
    }
}

这个异常是可以理解的，因为根据我前面问题的解决方案，GSON期望Enum对象实际创建为

${title}("${title}"),
${description}("${description}");

但由于这在语法上是不可能的，建议的解决方案和解决办法是什么？

来自：

Gson为枚举提供默认序列化和反序列化。。。如果希望更改默认表示形式，可以通过GsonBuilder.registerTypeAdapter（类型，对象）注册类型适配器

以下就是这样一种方法

import java.io.FileReader;
import java.lang.reflect.Type;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;

public class GsonFoo
{
  public static void main(String[] args) throws Exception
  {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeAdapter(AttributeScope.class, new AttributeScopeDeserializer());
    Gson gson = gsonBuilder.create();

    TruncateElement element = gson.fromJson(new FileReader("input.json"), TruncateElement.class);

    System.out.println(element.lower);
    System.out.println(element.upper);
    System.out.println(element.delimiter);
    System.out.println(element.scope.get(0));
  }
}

class AttributeScopeDeserializer implements JsonDeserializer<AttributeScope>
{
  @Override
  public AttributeScope deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
      throws JsonParseException
  {
    AttributeScope[] scopes = AttributeScope.values();
    for (AttributeScope scope : scopes)
    {
      if (scope.scope.equals(json.getAsString()))
        return scope;
    }
    return null;
  }
}

class TruncateElement
{
  int lower;
  int upper;
  String delimiter;
  List<AttributeScope> scope;
}

enum AttributeScope
{
  TITLE("${title}"), DESCRIPTION("${description}");

  String scope;

  AttributeScope(String scope)
  {
    this.scope = scope;
  }
}

导入java.io.FileReader；
导入java.lang.reflect.Type；
导入java.util.List；
导入com.google.gson.gson；
导入com.google.gson.GsonBuilder；
导入com.google.gson.JsonDeserializationContext；
导入com.google.gson.JsonDeserializer；
导入com.google.gson.JsonElement；
导入com.google.gson.JsonParseException；
公共类GsonFoo
{
公共静态void main（字符串[]args）引发异常
{
GsonBuilder GsonBuilder=新的GsonBuilder（）；
gsonBuilder.registerTypeAdapter（AttributeScope.class，新的AttributeScopeDeserializer（））；
Gson-Gson=gsonBuilder.create（）；
TruncateElement=gson.fromJson（新文件读取器（“input.json”），TruncateElement.class）；
System.out.println（element.lower）；
System.out.println（element.upper）；
System.out.println（element.delimiter）；
System.out.println（element.scope.get（0））；
}
}
类AttributeScopeDeserializer实现JsonDeserializer
{
@凌驾
公共属性作用域反序列化（JsonElement json，类型typeOfT，JsonDeserializationContext）
抛出JsonParseException
{
AttributeScope[]范围=AttributeScope.values（）；
for（AttributeScope作用域：作用域）
{
if（scope.scope.equals（json.getAsString（）））
返回范围；
}
返回null；
}
}
类截断元素
{
int较低；
int-upper；
字符串分隔符；
清单范围；
}
枚举属性范围
{
标题（${TITLE}）、说明（${DESCRIPTION}）；
字符串范围；
AttributeScope（字符串范围）
{
this.scope=范围；
}
}

使用注释

@SerializedName

：

@SerializedName("${title}")
TITLE,
@SerializedName("${description}")
DESCRIPTION

---

我想扩展一点NAZIK/user2724653答案（针对我的案例）。下面是一个Java代码：

public class Item {
    @SerializedName("status")
    private Status currentState = null;

    // other fields, getters, setters, constructor and other code...

    public enum Status {
        @SerializedName("0")
        BUY,
        @SerializedName("1")
        DOWNLOAD,
        @SerializedName("2")
        DOWNLOADING,
        @SerializedName("3")
        OPEN
     }
}

在json文件中，您只有一个字段

“status”：“N”，

，其中N=0,1,2,3-取决于状态值。就这样，

GSON

可以很好地处理嵌套的

enum

类的值。在我的例子中，我从

json

数组中解析了

项的列表：

List<Item> items = new Gson().<List<Item>>fromJson(json,
                                          new TypeToken<List<Item>>(){}.getType());

List items=new Gson（）.fromJson（json，
新的TypeToken（）{}.getType（））；
使用GSON 2.2.2版enum，可以轻松编组和解编

import com.google.gson.annotations.SerializedName;

enum AttributeScope
{
  @SerializedName("${title}")
  TITLE("${title}"),

  @SerializedName("${description}")
  DESCRIPTION("${description}");

  private String scope;

  AttributeScope(String scope)
  {
    this.scope = scope;
  }

  public String getScope() {
    return scope;
  }
}

如果确实要使用枚举的序号值，可以注册类型适配器工厂以覆盖Gson的默认工厂

public class EnumTypeAdapter <T extends Enum<T>> extends TypeAdapter<T> {
    private final Map<Integer, T> nameToConstant = new HashMap<>();
    private final Map<T, Integer> constantToName = new HashMap<>();

    public EnumTypeAdapter(Class<T> classOfT) {
        for (T constant : classOfT.getEnumConstants()) {
            Integer name = constant.ordinal();
            nameToConstant.put(name, constant);
            constantToName.put(constant, name);
        }
    }
    @Override public T read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }
        return nameToConstant.get(in.nextInt());
    }

    @Override public void write(JsonWriter out, T value) throws IOException {
        out.value(value == null ? null : constantToName.get(value));
    }

    public static final TypeAdapterFactory ENUM_FACTORY = new TypeAdapterFactory() {
        @SuppressWarnings({"rawtypes", "unchecked"})
        @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
            Class<? super T> rawType = typeToken.getRawType();
            if (!Enum.class.isAssignableFrom(rawType) || rawType == Enum.class) {
                return null;
            }
            if (!rawType.isEnum()) {
                rawType = rawType.getSuperclass(); // handle anonymous subclasses
            }
            return (TypeAdapter<T>) new EnumTypeAdapter(rawType);
        }
    };
}

下面的代码片段使用自Gson 2.3起提供的
@JsonAdapter（class）
注释，不再需要显式的
Gson.registerTypeAdapter（…）
（请参见注释）

@JsonAdapter（Level.Serializer.class）
公共枚举级别{
WTF（0），
错误（1），
警告（2），
信息（3），
调试（4），
冗长的（5）；
整数级编码；
级别（int-levelCode）{
this.levelCode=levelCode；
}
静态级别getLevelByCode（int-levelCode）{
对于（级别：values（））
if（level.levelCode==levelCode）返回级别；
退货信息；
}
静态类序列化程序实现JsonSerializer、JsonDeserializer{
@凌驾
公共JsonElement序列化（级别src，类型typeOfSrc，JsonSerializationContext）{
返回context.serialize（src.levelCode）；
}
@凌驾
公共级反序列化（JsonElement json，类型typeOfT，JsonDeserializationContext）{
试一试{
返回getLevelByCode（json.getAsNumber（）.intValue（））；
}捕获（JSONParsee异常）{
退货信息；
}
}
}
}
使用此方法

GsonBuilder.enableComplexMapKeySerialization();

这个答案完美地解决了所有问题，不需要类型适配器！当我这样做的时候，使用reformation/Gson，枚举值的SerializedName添加了额外的引号。例如，服务器实际上接收的是
“1”
，而不是简单的
1
。如果状态为5的json到达，会发生什么？有没有办法定义默认值？@DmitryBorodin如果JSON中的值与任何
SerializedName
不匹配，则枚举将默认为
null
。未知状态的默认行为可以在包装器类中处理。但是，如果您需要除
null
之外的“unknown”表示，则需要编写自定义反序列化程序或类型适配器。请注意，此注释仅在版本2.3开始时可用：请小心将序列化程序/反序列化程序类添加到proguard配置中，因为它们可能会被删除（我就是这样做的）虽然这段代码可以回答这个问题，但提供关于如何和/或为什么解决问题的附加上下文将提高答案的长期价值。从gson 2.8.5开始，这是必需的，以便在要用作键的枚举上使用SerializedName注释
Gson gson = new GsonBuilder()
               .registerTypeAdapterFactory(EnumTypeAdapter.ENUM_FACTORY)
               .create();

@JsonAdapter(Level.Serializer.class)
public enum Level {
    WTF(0),
    ERROR(1),
    WARNING(2),
    INFO(3),
    DEBUG(4),
    VERBOSE(5);

    int levelCode;

    Level(int levelCode) {
        this.levelCode = levelCode;
    }

    static Level getLevelByCode(int levelCode) {
        for (Level level : values())
            if (level.levelCode == levelCode) return level;
        return INFO;
    }

    static class Serializer implements JsonSerializer<Level>, JsonDeserializer<Level> {
        @Override
        public JsonElement serialize(Level src, Type typeOfSrc, JsonSerializationContext context) {
            return context.serialize(src.levelCode);
        }

        @Override
        public Level deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {
            try {
                return getLevelByCode(json.getAsNumber().intValue());
            } catch (JsonParseException e) {
                return INFO;
            }
        }
    }
}

GsonBuilder.enableComplexMapKeySerialization();