如何解析来自同一字段的多类型值的 json 响应？
Posted
技术标签:
【中文标题】如何解析来自同一字段的多类型值的 json 响应？【英文标题】：How to parse a json response with multi type values coming for same field? 【发布时间】：2022-01-03 17:48:55 【问题描述】：如何从 kotlin 中的 json 响应中解析 answerData 键，因为它正在更改每个块中的类型？我尝试保留它，但无法输入强制转换。如何解析 answerData？
"status": "OK",
"data": [
"id": 10,
"answerData": null
,
"id": 21,
"answerData":
"selectionOptionId": 0,
"selectionOptionText": null
,
"id": 45,
"answerData":
"IsAffiliatedWithSeller": false,
"AffiliationDescription": null
,
"id" : 131,
"answerData" : [
"2" : "Chapter 11" ,
"3" : "Chapter 12" ,
"1" : "Chapter 7"
]
,
"id" : 140,
"answerData" : [
"liabilityTypeId" : 2,
"monthlyPayment" : 200,
"remainingMonth" : 2,
"liabilityName" : "Separate Maintenance",
"name" : "Two"
,
"liabilityTypeId" : 1,
"monthlyPayment" : 300,
"remainingMonth" : 1,
"liabilityName" : "Child Support",
"name" : "Three"
]
]
【问题讨论】：
你需要一个自定义的反序列化器，但老实说，这将是一团糟。它不仅需要到处进行强制转换和类型检查，而且很容易破坏。我会避免这种难以处理的 JSON 结构。 Gson 对此没有内置功能。正如@JoãoDias 提到的，您将需要检查某些字段的自定义类型适配器。如果可能的话，你可以试试 Jackson，它支持 deducing the type from the present fields，另见 ***.com/a/66167694。或者您让 Gson 将其解析为JsonObject，但随后您需要手动检查以获取属性。
【参考方案1】：
正如在其他答案中评论和解释的那样，您确实应该要求更改 JSON 格式。但是，列出其中包含的数据不同的元素并不少见。对于这种情况，至少应该有一些字段指示要反序列化的数据的类型。 （并不是说它不是反模式，有时它可能是）。
如果您达成该协议，则可以使用 - 例如 - RuntimeTypeAdapterFactory 就像在链接问题中解释的那样（对不起，它是 Java）。
否则你会遇到麻烦。隔离问题仍然很容易。并不是说这很容易解决。我提出了一种可能的解决方案（再次抱歉，Java，但猜想它很容易适应 Kotlin）解决方案。我使用了很多内部静态类来使代码更紧凑。实际逻辑没有那么多行，大部分代码都是把你的JSON映射成java类。
以不妨碍 Gson 在该有问题的领域中完成其工作的方式抽象模型：
@Getter @Setter
public class Response
private String status;
@Getter @Setter
public static class DataItem
private Long id;
// below 2 rows explained later, this is what changes
@JsonAdapter(AnswerDataDeserializer.class)
private AnswerData answerData;
private DataItem[] data;
如您所见，声明了 AnswerData 和 @JsonAdapter 用于处理实际更复杂的内容：
public class AnswerDataDeserializer
implements JsonDeserializer<AnswerDataDeserializer.AnswerData>
private final Gson gson = new Gson();
// The trick that makes the field more abstract. No necessarily
// needed answerData might possibly be just Object
public interface AnswerData
// just to have something here not important
default String getType()
return getClass().getName();
// here I have assumed Map<K,V> because of field name cannot be plain number.
@SuppressWarnings("serial")
public static class ChapterDataAnswer extends ArrayList<Map<Long, String>>
implements AnswerData
@SuppressWarnings("serial")
public static class LiabilityDataAnswer
extends ArrayList<LiabilityDataAnswer.LiabilityData>
implements AnswerData
@Getter @Setter
public static class LiabilityData
private Long liabilityTypeId;
private Double monthlyPayment;
private Integer remainingMonth;
private String liabilityName;
private String name;
@Override
public AnswerData deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context)
throws JsonParseException
if(json.isJsonArray())
try
return gson.fromJson(json, ChapterDataAnswer.class);
catch (Exception e)
return gson.fromJson(json, LiabilityDataAnswer.class);
if(json.isJsonObject())
// do something else
return null;
我上面只介绍了两种更复杂的数组类型。但是正如您所看到的，您必须以某种方式检查/查看所有反序列化的 AnswerData 以确定方法 deserialize 中的实际类型@
现在您还需要了解不同类型的AnswerData。也许有这样的类型以您无法确定类型的方式发生冲突。
注意：您也可以始终将整个内容或任何对象反序列化为 Map 或 Object（如果我没记错的话，Gson 将使其变为 LinkedHashMap）
无论你怎么做，你仍然需要在反序列化后检查对象的实例它是什么并使用强制转换。
【讨论】：
【参考方案2】：输入 JSON 的设计很糟糕，真的很难使用。 让我这么说：
-
它将
answerData 属性的元素和集合与数十个缺点混合在一起；
answer 元素缺少类型鉴别器字段，因此反序列化必须分析每个 JSON 树以生成有效的反序列化对象，并带有另外十几个缺点（包括“无法准确确定确切的类型”和“它可能需要由于 JSON 树导致内存过多”）；
OpenAPI/Swagger 等一些工具使用鉴别器字段反序列化为专用类型，而无需进行任何启发式操作。
Any 当然不适合你，因为 Gson 甚至不知道这些有效负载应该被反序列化成什么。
由于您没有提供映射，我将提供我的一个示例，说明如何反序列化如此糟糕的 JSON 文档。 这还包括：
-
使用 Java 11 和 Lombok 而不是 Kotlin（正如您在通知中所说的那样并不重要）；
即使传入的 JSON 节点包含对象而不是数组以统一所有这些，也将答案与答案列表映射；
创建一个演绎反序列化器，它天真地做了一些“魔术”来摆脱糟糕的 JSON 设计。
为了解决第一个问题，元素与数组/列表，我在S.O. 找到了一个现成的解决方案：
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
public final class AlwaysListTypeAdapterFactory<E> implements TypeAdapterFactory
@Nullable
@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken)
if (!List.class.isAssignableFrom(typeToken.getRawType()))
return null;
final Type elementType = resolveTypeArgument(typeToken.getType());
@SuppressWarnings("unchecked")
final TypeAdapter<E> elementTypeAdapter = (TypeAdapter<E>) gson.getAdapter(TypeToken.get(elementType));
@SuppressWarnings("unchecked")
final TypeAdapter<T> alwaysListTypeAdapter = (TypeAdapter<T>) new AlwaysListTypeAdapter<>(elementTypeAdapter).nullSafe();
return alwaysListTypeAdapter;
private static Type resolveTypeArgument(final Type type)
if (!(type instanceof ParameterizedType))
return Object.class;
final ParameterizedType parameterizedType = (ParameterizedType) type;
return parameterizedType.getActualTypeArguments()[0];
private static final class AlwaysListTypeAdapter<E> extends TypeAdapter<List<E>>
private final TypeAdapter<E> elementTypeAdapter;
private AlwaysListTypeAdapter(final TypeAdapter<E> elementTypeAdapter)
this.elementTypeAdapter = elementTypeAdapter;
@Override
public void write(final JsonWriter out, final List<E> list)
throw new UnsupportedOperationException();
@Override
public List<E> read(final JsonReader in) throws IOException
final List<E> list = new ArrayList<>();
final JsonToken token = in.peek();
switch ( token )
case BEGIN_ARRAY:
in.beginArray();
while ( in.hasNext() )
list.add(elementTypeAdapter.read(in));
in.endArray();
break;
case BEGIN_OBJECT:
case STRING:
case NUMBER:
case BOOLEAN:
list.add(elementTypeAdapter.read(in));
break;
case NULL:
throw new AssertionError("Must never happen: check if the type adapter configured with .nullSafe()");
case NAME:
case END_ARRAY:
case END_OBJECT:
case END_DOCUMENT:
throw new MalformedJsonException("Unexpected token: " + token);
default:
throw new AssertionError("Must never happen: " + token);
return list;
接下来，对于项目编号。 2、推导类型适配器工厂可以这样实现：
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
public final class DeducingTypeAdapterFactory<V> implements TypeAdapterFactory
public interface TypeAdapterProvider
@Nonnull
<T> TypeAdapter<T> provide(@Nonnull TypeToken<T> typeToken);
private final Predicate<? super TypeToken<?>> isSupported;
private final BiFunction<? super JsonElement, ? super TypeAdapterProvider, ? extends V> deduce;
public static <V> TypeAdapterFactory create(final Predicate<? super TypeToken<?>> isSupported,
final BiFunction<? super JsonElement, ? super TypeAdapterProvider, ? extends V> deduce)
return new DeducingTypeAdapterFactory<>(isSupported, deduce);
@Override
@Nullable
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken)
if (!isSupported.test(typeToken))
return null;
final Map<TypeToken<?>, TypeAdapter<?>> cache = new ConcurrentHashMap<>();
final TypeAdapter<V> deducedTypeAdapter = new TypeAdapter<V>()
@Override
public void write(final JsonWriter jsonWriter, final V value)
throw new UnsupportedOperationException();
@Override
public V read(final JsonReader jsonReader)
final JsonElement jsonElement = Streams.parse(jsonReader);
return deduce.apply(jsonElement, new TypeAdapterProvider()
@Nonnull
@Override
public <TT> TypeAdapter<TT> provide(@Nonnull final TypeToken<TT> typeToken)
final TypeAdapter<?> cachedTypeAdapter = cache.computeIfAbsent(typeToken, tt -> gson.getDelegateAdapter(DeducingTypeAdapterFactory.this, tt));
@SuppressWarnings("unchecked")
final TypeAdapter<TT> typeAdapter = (TypeAdapter<TT>) cachedTypeAdapter;
return typeAdapter;
);
.nullSafe();
@SuppressWarnings("unchecked")
final TypeAdapter<T> typeAdapter = (TypeAdapter<T>) deducedTypeAdapter;
return typeAdapter;
基本上，它不会自我推导，而只会使用Strategy 设计模式将过滤和推导工作委托给其他地方。
现在让我们假设您的映射足够“通用”（包括使用 @JsonAdapter 代替 Answer 来强制单个元素成为列表）：
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode
@ToString
final class Response<T>
@Nullable
@SerializedName("status")
private final String status;
@Nullable
@SerializedName("data")
private final T data;
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode
@ToString
final class Answer
@SerializedName("id")
private final int id;
@Nullable
@SerializedName("answerData")
@JsonAdapter(AlwaysListTypeAdapterFactory.class)
private final List<AnswerDatum> answerData;
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
abstract class AnswerDatum
interface Visitor<R>
R visit(@Nonnull Type1 answerDatum);
R visit(@Nonnull Type2 answerDatum);
R visit(@Nonnull Type3 answerDatum);
R visit(@Nonnull Type4 answerDatum);
abstract <R> R accept(@Nonnull Visitor<? extends R> visitor);
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = false)
static final class Type1 extends AnswerDatum
@SerializedName("selectionOptionId")
private final int selectionOptionId;
@Nullable
@SerializedName("selectionOptionText")
private final String selectionOptionText;
@Override
<R> R accept(@Nonnull final Visitor<? extends R> visitor)
return visitor.visit(this);
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = false)
static final class Type2 extends AnswerDatum
@SerializedName("IsAffiliatedWithSeller")
private final boolean isAffiliatedWithSeller;
@Nullable
@SerializedName("AffiliationDescription")
private final String affiliationDescription;
@Override
<R> R accept(@Nonnull final Visitor<? extends R> visitor)
return visitor.visit(this);
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = false)
static final class Type3 extends AnswerDatum
@Nonnull
private final String key;
@Nullable
private final String value;
@Override
<R> R accept(@Nonnull final Visitor<? extends R> visitor)
return visitor.visit(this);
@RequiredArgsConstructor(access = AccessLevel.PACKAGE, staticName = "of")
@Getter
@EqualsAndHashCode(callSuper = false)
@ToString(callSuper = false)
static final class Type4 extends AnswerDatum
@SerializedName("liabilityTypeId")
private final int liabilityTypeId;
@SerializedName("monthlyPayment")
private final int monthlyPayment;
@SerializedName("remainingMonth")
private final int remainingMonth;
@Nullable
@SerializedName("liabilityName")
private final String liabilityName;
@Nullable
@SerializedName("name")
private final String name;
@Override
<R> R accept(@Nonnull final Visitor<? extends R> visitor)
return visitor.visit(this);
注意AnswerDatum 如何使用Visitor 设计模式来避免显式类型转换。
我不确定在使用 sealed classes 时如何在 Java 中使用它。
public final class DeducingTypeAdapterFactoryTest
private static final Pattern digitsPattern = Pattern.compile("^\\d+$");
private static final TypeToken<String> stringTypeToken = new TypeToken<>() ;
private static final TypeToken<AnswerDatum.Type1> answerDatumType1TypeToken = new TypeToken<>() ;
private static final TypeToken<AnswerDatum.Type2> answerDatumType2TypeToken = new TypeToken<>() ;
private static final TypeToken<AnswerDatum.Type4> answerDatumType4TypeToken = new TypeToken<>() ;
private static final Gson gson = new GsonBuilder()
.disableInnerClassSerialization()
.disablehtmlEscaping()
.registerTypeAdapterFactory(DeducingTypeAdapterFactory.create(
typeToken -> AnswerDatum.class.isAssignableFrom(typeToken.getRawType()),
(jsonElement, getTypeAdapter) ->
if ( jsonElement.isJsonObject() )
final JsonObject jsonObject = jsonElement.getAsJsonObject();
// type-1? hopefully...
if ( jsonObject.has("selectionOptionId") )
return getTypeAdapter.provide(answerDatumType1TypeToken)
.fromJsonTree(jsonElement);
// type-2? hopefully...
if ( jsonObject.has("IsAffiliatedWithSeller") )
return getTypeAdapter.provide(answerDatumType2TypeToken)
.fromJsonTree(jsonElement);
// type-3? hopefully...
if ( jsonObject.size() == 1 )
final Map.Entry<String, JsonElement> onlyEntry = jsonObject.entrySet().iterator().next();
final String key = onlyEntry.getKey();
if ( digitsPattern.matcher(key).matches() )
final String value = getTypeAdapter.provide(stringTypeToken)
.fromJsonTree(onlyEntry.getValue());
return AnswerDatum.Type3.of(key, value);
// type-4? hopefully...
if ( jsonObject.has("liabilityTypeId") )
return getTypeAdapter.provide(answerDatumType4TypeToken)
.fromJsonTree(jsonElement);
throw new UnsupportedOperationException("can't parse: " + jsonElement);
))
.create();
private static final TypeToken<Response<List<Answer>>> listOfAnswerResponseType = new TypeToken<>() ;
@Test
public void testEqualsAndHashCode() throws IOException
final Object expected = Response.of(
"OK",
List.of(
Answer.of(
10,
null
),
Answer.of(
21,
List.of(
AnswerDatum.Type1.of(0, null)
)
),
Answer.of(
45,
List.of(
AnswerDatum.Type2.of(false, null)
)
),
Answer.of(
131,
List.of(
AnswerDatum.Type3.of("2", "Chapter 11"),
AnswerDatum.Type3.of("3", "Chapter 12"),
AnswerDatum.Type3.of("1", "Chapter 7")
)
),
Answer.of(
140,
List.of(
AnswerDatum.Type4.of(2, 200, 2, "Separate Maintenance", "Two"),
AnswerDatum.Type4.of(1, 300, 1, "Child Support", "Three")
)
)
)
);
try (final JsonReader jsonReader = openJsonInput())
final Object actual = gson.fromJson(jsonReader, listOfAnswerResponseType.getType());
Assertions.assertEquals(expected, actual);
@Test
public void testVisitor() throws IOException
final Object expected = List.of(
"21:0",
"45:false",
"131:2:Chapter 11",
"131:3:Chapter 12",
"131:1:Chapter 7",
"140:Two",
"140:Three"
);
try (final JsonReader jsonReader = openJsonInput())
final Response<List<Answer>> response = gson.fromJson(jsonReader, listOfAnswerResponseType.getType());
final List<Answer> data = response.getData();
assert data != null;
final Object actual = data.stream()
.flatMap(answer -> Optional.ofNullable(answer.getAnswerData())
.map(answerData -> answerData.stream()
.map(answerDatum -> answerDatum.accept(new AnswerDatum.Visitor<String>()
@Override
public String visit(@Nonnull final AnswerDatum.Type1 answerDatum)
return answer.getId() + ":" + answerDatum.getSelectionOptionId();
@Override
public String visit(@Nonnull final AnswerDatum.Type2 answerDatum)
return answer.getId() + ":" + answerDatum.isAffiliatedWithSeller();
@Override
public String visit(@Nonnull final AnswerDatum.Type3 answerDatum)
return answer.getId() + ":" + answerDatum.getKey() + ':' + answerDatum.getValue();
@Override
public String visit(@Nonnull final AnswerDatum.Type4 answerDatum)
return answer.getId() + ":" + answerDatum.getName();
)
)
)
.orElse(Stream.empty())
)
.collect(Collectors.toUnmodifiableList());
Assertions.assertEquals(expected, actual);
private static JsonReader openJsonInput() throws IOException
return // ... your code code here ...
就是这样。
我发现它非常困难且不必要地复杂。 请让您的服务器端伙伴永久修复他们的设计（注意当前情况如何使反序列化比设计良好时更难）。
【讨论】：
【参考方案3】：Json 响应错误。无需在客户端处理此响应，应从服务器端更改 Json 响应。否则，这将是你未来的巨大负担。一个 Json 对象应该有一个正确定义的键和它的值。
【讨论】：
但我无法让我的团队和后端人员了解这一点。所以我必须非常努力地去做。以上是关于如何解析来自同一字段的多类型值的 json 响应？的主要内容，如果未能解决你的问题，请参考以下文章
如何在 ios 中解析这种类型的 JSON 响应？ [复制]
是否有任何适当的匹配器来解析和比较来自 MockMvc 的 Json 响应中的 LocalDateTime 字段