使用Gson，您可以通过实现一个自定义的TypeAdapterFactory来解决这个问题，该TypeAdapterFactory执行以下操作：
1.验证请求的类型是否为ParentItem
1.创建一个从itemType字符串到对应的TypeAdapter的Map，从Gson示例中获得（以下称为“itemTypeMap”）
1.从Gson示例中获取JsonObject的适配器（在下面称为“JsonObject适配器”）
1.从Gson示例中获取ParentItem的 * 委托适配器 *（以下称为“ParentItem适配器”）（需要 * 委托 * 适配器，因为否则Gson将简单地使用当前ParentItem工厂，导致无限递归）
1.创建并返回执行以下操作的适配器：
1.使用JsonObject适配器从读取器读取
1.从已解析的JsonObject中删除childProperty值，并将其存储在变量childPropertyValue中
1.移除itemType值，并从itemTypeMap中取得Map的TypeAdapter（以下称为“子配接卡”）
1.在已解析的JsonObject上使用ParentItem适配器（没有childPropertyValue; Gson不会抱怨丢失的财产）
1.在childPropertyValue上使用子适配器，并将其结果存储在先前读取的ParentItem对象的childProperty中（这需要将ParentItem.childProperty设置为var）
1.返回ParentItem对象
然后，您只需要将该TypeAdapterFactory注册到GsonBuilder（以及可选的ChildPropertyFoo或ChildPropertyBar的任何自定义适配器）。
下面是TypeAdapterFactory的示例实现：

object ParentItemTypeAdapterFactory : TypeAdapterFactory {
    override fun <T : Any?> create(gson: Gson, type: TypeToken<T>): TypeAdapter<T>? {
        // Only support ParentItem and subtypes
        if (!ParentItem::class.java.isAssignableFrom(type.rawType)) {
            return null
        }

        // Safe cast due to check at beginning of function
        @Suppress("UNCHECKED_CAST")
        val delegateAdapter = gson.getDelegateAdapter(this, type) as TypeAdapter<ParentItem>
        val jsonObjectAdapter = gson.getAdapter(JsonObject::class.java)
        val itemTypeMap = mapOf(
            "foo" to gson.getAdapter(ChildPropertyFoo::class.java),
            "bar" to gson.getAdapter(ChildPropertyBar::class.java),
        )

        // Safe cast due to check at beginning of function
        @Suppress("UNCHECKED_CAST")
        return object : TypeAdapter<ParentItem>() {
            override fun read(reader: JsonReader): ParentItem? {
                if (reader.peek() == JsonToken.NULL) {
                    reader.nextNull()
                    return null
                }

                val parentItemValue = jsonObjectAdapter.read(reader)
                val itemType = parentItemValue.remove("itemType").asString
                val childAdapter = itemTypeMap[itemType]
                    ?: throw JsonParseException("Invalid item type: $itemType")
                val childPropertyValue = parentItemValue.remove("childProperty")

                val itemObject = delegateAdapter.fromJsonTree(parentItemValue)
                val childObject = childAdapter.fromJsonTree(childPropertyValue)
                itemObject.childProperty = childObject

                return itemObject
            }

            override fun write(writer: JsonWriter, value: ParentItem?) {
                throw UnsupportedOperationException()
            }
        } as TypeAdapter<T>
    }
}

请注意，其他JSON框架提供了这种现成的功能，例如Jackson有JsonTypeInfo.As.EXTERNAL_PROPERTY。

一种方法是为ParentItem类创建一个类型适配器，并在JsonDeserializer子类中基于itemType属性的值使用正确的类反序列化子对象（ChildPropertyFoo或ChildPropertyBar）。然后，您可以简单地将反序列化的对象赋给ChildProperty属性。但是，这将需要在ParentItem中将childProperty更改为var，因为它需要重新分配。
代码可能如下所示：

import com.google.gson.*
import java.lang.reflect.Type

internal class ItemDeserializer : JsonDeserializer<ParentItem> {

    override fun deserialize(
        json: JsonElement,
        t: Type,
        jsonDeserializationContext: JsonDeserializationContext
    )
            : ParentItem? {
        val type = (json as JsonObject)["itemType"].asString
        val gson = Gson()
        val childJson = json["childProperty"]
        val childClass = if (type == "foo") ChildPropertyFoo::class.java else ChildPropertyBar::class.java
        val childObject = gson.fromJson<ChildProperty>(childJson, childClass)
        val parent = gson.fromJson(json, ParentItem::class.java) as ParentItem
        parent.childProperty = childObject
        return parent
    }

}

当然，可以通过将itemType、childProperty等细节注入ItemDeserializer示例来概括整个过程，但我更希望展示基本方法。
无论如何，要获得一个用于快速测试的自包含示例，调用仍然缺失，可能如下所示：

import com.google.gson.GsonBuilder

fun main() {
    val deserializer = ItemDeserializer()
    val gson = GsonBuilder().registerTypeAdapter(ParentItem::class.java, deserializer).create()
    val deserializedTest = gson.fromJson(json, FooBarWrapper::class.java)
    for (item in deserializedTest.items) {
        when (val childProperty = item.childProperty) {
            is ChildPropertyFoo -> {
                println(childProperty.foo)
                println(childProperty.abc)
            }
            is ChildPropertyBar -> {
                println(childProperty.bar)
                println(childProperty.ghi)
            }
        }
    }
}

然后调试控制台将输出以下内容，您可以看到反序列化代码给出了所需的结果：

This property will be here if itemType is 'foo'
def
This property will be here if itemType is 'bar'
jkl