Json 使用杰克逊解析Kotlin 中的通用密封类

我有以下表示网络响应状态的泛型密封类.

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY, property = "status")
@JsonSubTypes(
    value = [
        JsonSubTypes.Type(value = Response.OK::class, name = "OK"),
        JsonSubTypes.Type(value = Response.Error::class, name = "ERROR"),
    ]
)
sealed class Response<out Content, out Error> {
    data class OK<out Content>(val content: Content) : Response<Content, Nothing>()
    data class Error<out Error>(val error: Error) : Response<Nothing, Error>()
}

网络响应JSON可以具有status": "OK"，在该情况下其包含content密钥，或者在"status": "ERROR"的情况下，其包含error密钥.

对于我正在与之交谈的每个端点，content和error键下的类型可以不同.因此需要泛型类型

例如，一个endpoit返回String作为类型，所以Response<String, String>

{
  "status": "OK",
  "content": "Hello"
}

{
  "status": "ERROR",
  "error": "MyError"
}

另一个endpoit返回Double作为内容，Int作为错误，因此

Response<Double, Int>个

{
  "status": "OK",
  "content": 2.0
}

{
  "status": "ERROR",
  "error": 1
}

我的解析失败，但出现消息

Could not resolve type id 'OK' as a subtype of `com.example.models.Response<java.lang.String,java.lang.String>`: Failed to specialize base type com.example.models.Response<java.lang.String,java.lang.String> as com.example.models.Response$OK, problem: Type parameter #1/2 differs; can not specialize java.lang.String with java.lang.Object
 at [Source: (String)"{
  "status": "OK",
  "content": "Hello"
}"; line: 2, column: 13]

@Nested
inner class ContentParsingTests {
    @Test
    fun `parses OK response`() {
        val json = """
    {
      "status": "OK",
      "content": "Hello"
    }
    """.trimIndent()

        when (val result = objectMapper.readValue<Response<String, String>>(json)) {
            is Response.OK -> {
                assertEquals(result.content, "Hello")
            }
            is Response.Error -> {
                fail()
            }
        }
    }

    @Test
    fun `parses ERROR response`() {
        val json = """
        {
          "status": "ERROR",
          "error": "MyError"
        }
    """.trimIndent()

        when (val result = objectMapper.readValue<Response<String, String>>(json)) {
            is Response.OK -> {
                fail()
            }
            is Response.Error -> {
                assertEquals(result.error, "MyError")
            }
        }
    }
}

我注意到，只要内容是泛型的，解析就可以很好地工作:

sealed class Response<out Content > {
    data class OK<out Content>(val content: Content) : Response<Content>()
    object Error : Response<Nothing>()
}

但当然，我丢失了错误有效载荷

将json解析成我的泛型类的正确方法是什么？