去序列化动态字段

Question

如果发生错误，数据栏将是这样的字符串：

{
  "code": 2001,
  "data": "Error!"
}

如果成功，数据字段将是一个对象：

{
  "code": 2000,
  "data": {
    "id": 1,
    "name": "example"
  }
}

我使用以下Kotlin代码对其进行反序列化：

return Gson().fromJson(data, SimpleModel::class.java)

模型定义如下：

import com.google.gson.annotations.SerializedName

class SimpleModel {
    @SerializedName("code")
    val code = 0

    @SerializedName("data")
    val data: SimpleData = SimpleData()
}

class SimpleData {
    @SerializedName("id")
    val id = ""

    @SerializedName("name")
    val name = ""
}

当没有错误发生时，上面的代码工作正常。但是当错误发生时，会引发异常：

java.lang.IllegalStateException: Excepted BEGIN_OBJECT but was STRING at line 1 column x $path.data

有没有办法将数据字段反序列化为对象或任何对象，并通过代码手动确定其类型？

Answer 1

像前面的答案一样，我不熟悉静态编程语言，下面的解决方案Java，但正如我所知，使用IntelliJ内置工具很容易将Java转换为静态编程语言。

成功/错误对象对是一个经典问题，您可以创建自己的解决方法，但是我们考虑以下类分别表示成功和错误对象（java 17，然后启用交换机上的模式匹配）：

abstract sealed class SimpleModel<T>
        permits SimpleModelSuccess, SimpleModelError {

    @SerializedName("code")
    final int code;

    SimpleModel(final int code) {
        this.code = code;
    }

}

final class SimpleModelSuccess<T>
        extends SimpleModel<T> {

    @SerializedName("data")
    final T data;

    private SimpleModelSuccess(final int code, final T data) {
        super(code);
        this.data = data;
    }

}

final class SimpleModelError<T>
        extends SimpleModel<T> {

    @SerializedName("data") // the annotation is helping here!
    final String message;

    private SimpleModelError(final int code, final String message) {
        super(code);
        this.message = message;
    }

}

上面的代码可以自我解释。现在的核心部分需要比我之前想象的更多的工作，我给你们提供了我的第一条评论，这似乎是不完整的。

@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
final class SimpleModelTypeAdapterFactory
        implements TypeAdapterFactory {

    @Getter
    private static final TypeAdapterFactory instance = new SimpleModelTypeAdapterFactory();

    @Override
    @Nullable
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        if ( !SimpleModel.class.isAssignableFrom(typeToken.getRawType()) ) {
            return null;
        }
        // let's figure out what the model is parameterized with
        final Type type = typeToken.getType();
        final Type typeParameter;
        if ( type instanceof ParameterizedType parameterizedType ) {
            typeParameter = parameterizedType.getActualTypeArguments()[0];
        } else {
            throw new UnsupportedOperationException("Cannot infer type parameter from " + type);
        }
        // then borrow their respective type adapters for both success and error cases
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> successDelegate = (TypeAdapter<T>) gson.getDelegateAdapter(this, TypeToken.getParameterized(SimpleModelSuccess.class, typeParameter));
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> errorDelegate = (TypeAdapter<T>) gson.getDelegateAdapter(this, TypeToken.getParameterized(SimpleModelError.class, typeParameter));
        return new TypeAdapter<>() {
            @Override
            public void write(final JsonWriter out, final T value) {
                throw new UnsupportedOperationException();
            }

            @Override
            public T read(final JsonReader in) {
                // buffer the JSON tree first
                // note that this solution may be very inefficient under some circumstances
                final JsonObject buffer = Streams.parse(in).getAsJsonObject();
                final JsonElement dataElement = buffer.get("data");
                // is it's data is {...}, the consider it is success (by the way, what is code about?)
                if ( dataElement.isJsonObject() ) {
                    return successDelegate.fromJsonTree(buffer);
                }
                // if it's a primitive, consider it's an error
                if ( dataElement.isJsonPrimitive() ) {
                    return errorDelegate.fromJsonTree(buffer);
                }
                // well we've done our best...
                throw new JsonParseException(String.format("Cannot deduce the model for %s", buffer.getClass()));
            }
        };
    }

}

java prettyprint-override">public final class SimpleModelTypeAdapterFactoryTest {

    private static final class SomeJsonProvider
            implements ArgumentsProvider {

        @Override
        public Stream<? extends Arguments> provideArguments(final ExtensionContext context) {
            return Stream.of(
                    Arguments.of(
                            """
                            {
                                "code": 2000,
                                "data": {
                                    "id": 1,
                                    "name": "example"
                                }
                            }
                            """
                    ),
                    Arguments.of(
                            """
                            {
                                "code": 2001,
                                "data": "Error!"
                            }
                            """
                    )
            );
        }

    }

    @AllArgsConstructor(access = AccessLevel.PRIVATE)
    @ToString
    private static final class SimpleData {

        private final String id;
        private final String name;

    }

    private static final Type simpleModelOfSimpleDataType = TypeToken.getParameterized(SimpleModel.class, SimpleData.class)
            .getType();

    @ParameterizedTest
    @ArgumentsSource(SomeJsonProvider.class)
    public void test(final String json) {
        final Gson gson = new GsonBuilder()
                .disableHtmlEscaping()
                .disableInnerClassSerialization()
                .registerTypeAdapterFactory(SimpleModelTypeAdapterFactory.getInstance())
                .create();
        final SimpleModel<SimpleData> model = gson.fromJson(json, simpleModelOfSimpleDataType);
        switch ( model ) {
        case SimpleModelSuccess<SimpleData> success -> System.out.println(success.data);
        case SimpleModelError<SimpleData> error -> System.out.println(error.message);
        }
    }

}

以下是它打印到标准输出的内容：

SimpleModelTypeAdapterFactoryTest. SimpleData（id=1， name=示例）
错误！

嗯，是的，这比我第一次评论中提到的要“有点”棘手。

Answer 2

您需要编写一个自定义的反序列化程序，它根据节点的运行时类型决定将数据反序列化到哪个类型，并将该反序列化程序注册到Gson实例中。不幸的是，我不熟悉kotlin语法，所以我只能给出伪代码。

1. SimpleModel中的字段data应该是Object，或者将类设置为泛型-SimpleModel

JsonElement root = parseResponse();
root.getAsJsonObject().get("data").getAsString();

你可以用我的答案作为灵感。虽然它是关于对象映射器的，但它做同样的事情——根据节点类型决定对象类型，并遵循与我上面描述的大致相同的算法。

此外，本指南还提供了有关如何编写或注册自己的反序列化程序的信息。