主页 / 问题 / 1544120
Accepted
Mikhail Murugov
Asked:2023-10-05 14:29:59 +0000 UTC2023-10-05 14:29:59 +0000 UTC

如何反序列化包含表示多态类型的序列化 json 对象的 json 字符串？

  • 772

有一个json对象，其字段之一是一个json字符串，其中包含一个序列化的json对象，需要反序列化为多态类型。如何使用杰克逊注释来做到这一点？使用的版本是 Jackson 2.14.0。
如果在代码级别，那么您需要以某种方式更改data class以使测试通过：

data class Zoo(
    val animal: Animal
)

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type"
)
@JsonSubTypes(
    JsonSubTypes.Type(Cat::class, name = "cat"),
    JsonSubTypes.Type(Dog::class, name = "dog"),
)
interface Animal

data class Cat(
    val meow: String,
) : Animal

data class Dog(
    val woof: String,
) : Animal

class TestDeser {
    private val objectMapper: ObjectMapper = ObjectMapper().findAndRegisterModules()

    @Test
    fun testDeserialize() {
        val catJson = "{\"animal\":\"{\\\"type\\\":\\\"cat\\\",\\\"meow\\\":\\\"catValue\\\"}\"}"
        val dogJson = "{\"animal\":\"{\\\"type\\\":\\\"dog\\\",\\\"woof\\\":\\\"dogValue\\\"}\"}"

        val zooWithCat = this.objectMapper.readValue<Zoo>(catJson)
        val cat = zooWithCat.animal
        Assertions.assertTrue(cat is Cat)
        cat as Cat
        Assertions.assertEquals("catValue", cat.meow)

        val zooWithDog = this.objectMapper.readValue<Zoo>(dogJson)
        val dog = zooWithDog.animal
        Assertions.assertTrue(dog is Dog)
        dog as Dog
        Assertions.assertEquals("dogValue", dog.woof)
    }
}

我尝试过的：

  1. 我尝试编写自己的JsonDeserializer：

    class MyDeserializer : StdDeserializer<Animal>(Animal::class.java) {
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Animal {
        val str = p.valueAsString
        return (p.codec as ObjectMapper).readValue(str)
    }
}

data class Zoo(
    @JsonDeserialize(using = MyDeserializer::class)
    val animal: Animal,
)

    我将这种方法用于常规类型，而不是多态类型，并且它有效。对于多态类型，deserialize它甚至不进入方法。

  2. 我想尝试使用Converter

    class MyConverter : StdConverter<String, Animal>() {
   override fun convert(value: String): Animal {
      TODO("Нет доступа к ObjectMapper :(")
   }
}

data class Zoo(
   @JsonDeserialize(converter = MyConverter::class)
   val animal: Animal,
)

    但如果使用转换器ObjectMapper，则无法将字符串转换为 POJO

java

3 个回答

  1. 我已经很长时间没有使用它了Jackson，也许JsonSubTypes以某种方式是可能的，但这正是它的工作原理。

    class MyDeserializer : StdDeserializer<Animal>(Animal::class.java) {
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Animal? {
        val animal = p.readValueAsTree<JsonNode>().asText()
        return when {
            animal.contains("cat") -> {
                (p.codec as ObjectMapper).readValue(animal, Cat::class.java)
            }
            animal.contains("dog") -> {
                (p.codec as ObjectMapper).readValue(animal, Dog::class.java)
            }
            else -> { // не обязательно
                null
            }
        }
    }
}

data class Zoo(
    @JsonDeserialize(using = MyDeserializer::class)
    @JsonProperty("animal")
    val animal: Animal
)

interface Animal

@JsonIgnoreProperties(ignoreUnknown = true)
data class Cat(
    @JsonProperty("meow")
    val meow: String,
) : Animal

@JsonIgnoreProperties(ignoreUnknown = true)
data class Dog(
    @JsonProperty("woof")
    val woof: String,
) : Animal
    • 1

  2. 在 Gson 中，这是通过一个地方完成的。序列化时，我们在输入类型的地方插入一个附加字段；反序列化时，我们将其扩展为一个真正的类，如下所示：

    public class FieldMarshaller implements JsonDeserializer<Field>, JsonSerializer<Field> {
    public final String FIELD_META_KEY="clz";

    @Override
    public Field deserialize(JsonElement jsonElement, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jsonObj = jsonElement.getAsJsonObject();
        String className = jsonObj.get(FIELD_META_KEY).getAsString();
        try {
            Class<?> clz = Class.forName(className);
            return context.deserialize(jsonElement, clz);
        } catch (ClassNotFoundException e) {
            throw new JsonParseException(e);
        }
    }

    @Override
    public JsonElement serialize(Field field, Type typeOfSrc, JsonSerializationContext context) {
        JsonElement jsonElement = context.serialize(field, typeOfSrc);
        jsonElement.getAsJsonObject().addProperty(FIELD_META_KEY, field.getClass().getCanonicalName());
        return jsonElement;
    }
}

    此示例序列化/反序列化一个抽象类Field。在序列化期间，我们插入一个附加字段 clz，在其中写入类的名称，在反序列化期间，我们调用其反序列化器，向其传递类的真实名称。

    一般来说，最好切换到 kotlinx-serialization - 它自动支持抽象密封类的序列化/反序列化，示例在这里

    • 0
  3. Best Answer

    我忘记了我们只能改变班级的条件Zoo。Animal我们无法改变它的后代。

    我设法想出了这样一个弯曲但有效的解决方案：

    class StringEncodedJsonDeserializer : JsonDeserializer<Any>() {
    override fun deserialize(
        p: JsonParser,
        ctxt: DeserializationContext,
    ): Any {
        val str = p.valueAsString
        return (p.codec as ObjectMapper).readValue(str)
    }

    override fun deserializeWithType(
        p: JsonParser,
        ctxt: DeserializationContext,
        typeDeserializer: TypeDeserializer,
    ): Any {
        val raw = this.deserialize(p, ctxt)
        return (p.codec as ObjectMapper)
            .convertValue(
                raw,
                (typeDeserializer as TypeDeserializerBase).baseType()
            )
    }
}

data class Zoo(
    @JsonDeserialize(using = StringEncodedJsonDeserializer::class)
    val animal: Animal,
)
    • 0

相关问题