我认为这里有几个不同的问题需要解决，所以我列出了三种不同的方法。

或者正确使用Jackson多态性，或者在您的情况下，使用更简单的方法，消除多态性的需要。在github上查看我的代码。

格式化后的 JSON 为：

{ inventory:
   [ { productType: 'someProduct1',
       details:
        { productId: 'Some_id',
          description: 'some description' } },
     { productType: 'someProduct2',
       details:
        { productId: 'Some_id',
          description: { someKey: 'somevalue' } 
        }
     } 
   ]
}

在我看来，字段< code>productType放错了位置，但是如果这种格式是一个严格的要求，那么您可以编写自己的反序列化器，它查看< code>productType字段并实例化一个不同的具体类。

我不认为这是最好的解决方案，所以我没有编写示例代码，但我喜欢将Joda日期时间包作为自定义序列化/反序列化的参考

您用一个类型字段将Product与ProductsDetails分开：

case class Product(productType:String,details:ProductDetails)

abstract class ProductDetails

我认为您已经混淆了Jackson的多态数据类型处理是如何工作的，并因此使您的类设计变得复杂。

也许您的业务规则要求产品具有“类型”，在这种情况下，我会将其命名为“类型”或其他非代码标签，并将其放入您所谓的Product详细信息中。

但是，如果在尝试获得类型多态性时包含“类型”，那么这不是正确的方法。

我将以下内容作为Scala中Jackson多态性的工作示例：

/**
 * The types here are close to the original question types but use 
 * Jackson annotations to mark the polymorphic JSON treatment.
 */

import scala.Array
import com.fasterxml.jackson.annotation.JsonSubTypes.Type
import com.fasterxml.jackson.annotation.{JsonSubTypes, JsonTypeInfo}

@JsonTypeInfo(
  use = JsonTypeInfo.Id.NAME,
  include = JsonTypeInfo.As.PROPERTY,
  property = "type")
@JsonSubTypes(Array(
  new Type(value = classOf[ProductDetailsSimple], name = "simple"),
  new Type(value = classOf[ProductDetailsComplex], name = "complex")
))
abstract class Product

case class ProductDetailsSimple(productId: String, description: String) extends Product

case class ProductDetailsComplex(productId: String, description: Map[String, String]) extends Product

case class PolymorphicInventory(products: List[Product])

请注意，我删除了Product与ProductsDetails的区别，因此Inventory现在只是一个Product列表。我留下了名称ProductDetailsSimple和ProductsDetailsComplex，尽管我认为它们应该重命名。

用法示例：

val inv = PolymorphicInventory(
  List(
    ProductDetailsSimple(productId="Some_id", description="some description"),
    ProductDetailsComplex(productId="Some_id", description=Map("someKey" -> "somevalue"))
  )
)

val s = jsonMapper.writerWithDefaultPrettyPrinter().writeValueAsString(inv)
println("Polymorphic Inventory as JSON: "+s)

输出：

Polymorphic Inventory as JSON: {
  "products" : [ {
    "type" : "simple",
    "productId" : "Some_id",
    "description" : "some description"
  }, {
    "type" : "complex",
    "productId" : "Some_id",
    "description" : {
      "someKey" : "somevalue"
    }
  } ]
}

我建议在这种情况下根本不需要多态性，错误在于尝试将“描述”设为单个字符串或键/值映射，而它们实际上是具有不同意图的字段。

也许涉及数据遗留问题（在这种情况下，请参阅自定义设计建议），但如果数据在您的控制之下，我投票支持“变得更简单”：

case class Product(productId: String,
                   description: String="",
                   attributes: Map[String, String]=Map.empty)

case class PlainInventory(products: List[Product])

使用< code>Option来表示缺少值更“标量”,所以:

case class Product(productId: String,
                   description: Option[String]=None,
                   attributes: Option[Map[String, String]]=None)

用法示例：

val inv = PlainInventory(
  List(
    Product(productId="Some_id", description=Some("some description")),
    Product(productId="Some_id", attributes=Some(Map("someKey" -> "somevalue")))
  )
)

val s = jsonMapper.writerWithDefaultPrettyPrinter().writeValueAsString(inv)
println("Plain Inventory as JSON: "+s)

输出：

Plain Inventory as JSON: {
  "products" : [ {
    "productId" : "Some_id",
    "description" : "some description"
  }, {
    "productId" : "Some_id",
    "attributes" : {
      "someKey" : "somevalue"
    }
  } ]
}

在github上运行最少的代码。