在用 GSON 解析 JSON 时使用 Enums

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

使用 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;
}
}

这段代码抛出一个异常,

com.google.gson.JsonParseException: The JsonDeserializer EnumTypeAdapter failed to deserialized json object "${title}" given the type class com.amazon.seo.attribute.template.parse.data.AttributeScope
at

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

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

但是，既然这在语法上是不可能的，那么推荐的解决方案是什么，变通方法？

113076 次浏览
小开
最佳答案

来自 Gson 的文件:

Gson 为 Enums 提供了默认的序列化和反序列化... ... 如果您希望更改默认的表示形式，可以通过 GsonBuilder.registerTypeAdapter (Type，Object)注册一个类型适配器。

下面就是这样一种方法。

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;
}
}
小开

使用注释 @SerializedName:

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

我想展开一下 NAZIK/user2724653的答案(针对我的情况):

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-取决于 Status 值。这样就可以了，GSON可以很好地处理嵌套 enum类的值。在我的例子中，我解析了 json数组中的 Items列表:

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

使用 GSON 2.2.2版本，枚举可以很容易地编组和解组。

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;
}
}
小开

如果您确实希望使用 Enum 的序号值，可以注册一个类型适配器工厂来覆盖 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 gson = new GsonBuilder()
.registerTypeAdapterFactory(EnumTypeAdapter.ENUM_FACTORY)
.create();
小开

下面的代码片段消除了显式 Gson.registerTypeAdapter(...)的必要性，使用了自 Gson 2.3以来提供的 @JsonAdapter(class)注释(参见注释 实验室)。

@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();

提交答案