含Animal特质的Student样例类JSON编解码问题求助

问题根源 #

你当前的代码直接为Animal特质派生编解码器是无效的——Circe无法处理无具体类型标识的特质：编码时会丢失子类的类型信息，解码时也无法判断应该实例化Cat还是Dog，最终导致编解码失败。

解决方案 #

要实现多态类型的正确编解码，需要让Circe能够识别子类的类型标识。下面提供两种可行方案：

方案1：使用Circe Generic Extras（推荐） #

该方案通过配置类型鉴别字段，自动处理密封特质的多态编解码，代码简洁易维护。

1. 添加依赖（SBT）

确保引入circe-generic-extras模块（版本与你的Circe主版本保持一致）：

libraryDependencies += "io.circe" %% "circe-generic-extras" % "0.14.6"
libraryDependencies += "io.circe" %% "circe-parser" % "0.14.6"

2. 完整实现代码

import io.circe._
import io.circe.generic.semiauto._
import io.circe.generic.extras._
import io.circe.generic.extras.semiauto._

// 将Animal改为密封特质，限定子类范围
sealed trait Animal

case class Cat(name: String) extends Animal

case class Dog(name: String) extends Animal

case class Student(id: Int, name: String, animal: Animal)

object Student {
  // 配置类型鉴别规则：指定JSON中用于标识子类的字段名
  implicit val config: Configuration = Configuration.default.withDiscriminator("animalType")

  // 为子类派生基础编解码器
  implicit val catEncoder: Encoder[Cat] = deriveEncoder
  implicit val catDecoder: Decoder[Cat] = deriveDecoder
  implicit val dogEncoder: Encoder[Dog] = deriveEncoder
  implicit val dogDecoder: Decoder[Dog] = deriveDecoder

  // 使用配置好的规则为Animal派生多态编解码器
  implicit val animalEncoder: Encoder[Animal] = deriveConfiguredEncoder
  implicit val animalDecoder: Decoder[Animal] = deriveConfiguredDecoder

  // 派生Student的编解码器
  implicit val studentEncoder: Encoder[Student] = deriveEncoder
  implicit val studentDecoder: Decoder[Student] = deriveDecoder
}

object Test extends App {
  import io.circe.syntax._
  import io.circe.parser.decode

  val studentWithCat = Student(1, "abc", Cat("Mimi"))
  val studentWithDog = Student(2, "def", Dog("Buddy"))

  // 编码输出
  println("Cat Student JSON: " + studentWithCat.asJson.noSpaces)
  // 输出: {"id":1,"name":"abc","animal":{"animalType":"Cat","name":"Mimi"}}

  println("Dog Student JSON: " + studentWithDog.asJson.noSpaces)
  // 输出: {"id":2,"name":"def","animal":{"animalType":"Dog","name":"Buddy"}}

  // 解码输出
  println("Decoded Cat Student: " + decode[Student](studentWithCat.asJson.noSpaces))
  // 输出: Right(Student(1,abc,Cat(Mimi)))

  println("Decoded Dog Student: " + decode[Student](studentWithDog.asJson.noSpaces))
  // 输出: Right(Student(2,def,Dog(Buddy)))
}

关键说明

• 密封特质：sealed trait Animal确保所有子类都在当前文件中，Circe可以枚举所有可能的子类，避免解码时出现未知类型。
• Configuration：withDiscriminator("animalType")指定在JSON中添加类型标识字段，值为子类的类名（如"Cat"），让Circe能区分不同子类实例。
• deriveConfiguredEncoder/Decoder：使用配置好的规则为Animal派生编解码器，自动处理类型标识的添加和解析。

方案2：手动实现编解码器 #

如果不想引入额外依赖，可以手动为Animal实现编解码器，手动添加和解析类型标识：

import io.circe._
import io.circe.generic.semiauto._
import io.circe.syntax._

sealed trait Animal

case class Cat(name: String) extends Animal

case class Dog(name: String) extends Animal

case class Student(id: Int, name: String, animal: Animal)

object Student {
  // 子类基础编解码器
  implicit val catEncoder: Encoder[Cat] = deriveEncoder
  implicit val catDecoder: Decoder[Cat] = deriveDecoder
  implicit val dogEncoder: Encoder[Dog] = deriveEncoder
  implicit val dogDecoder: Decoder[Dog] = deriveDecoder

  // 手动实现Animal编码器：添加type字段标识子类
  implicit val animalEncoder: Encoder[Animal] = Encoder.instance {
    case cat: Cat => cat.asJson.mapObject(_.add("type", Json.fromString("Cat")))
    case dog: Dog => dog.asJson.mapObject(_.add("type", Json.fromString("Dog")))
  }

  // 手动实现Animal解码器：根据type字段匹配子类
  implicit val animalDecoder: Decoder[Animal] = Decoder.instance { c =>
    c.get[String]("type").flatMap {
      case "Cat" => c.as[Cat]
      case "Dog" => c.as[Dog]
      case unknownType => Left(DecodingFailure(s"未知动物类型: $unknownType", c.history))
    }
  }

  // Student编解码器
  implicit val studentEncoder: Encoder[Student] = deriveEncoder
  implicit val studentDecoder: Decoder[Student] = deriveDecoder
}

// Test代码与方案1一致

内容的提问来源于stack exchange，提问作者Randhir Kumar