无法在 Scala 中使用 Circe 解码子类

Question

我有一个 Scala 项目，我在其中使用 Circe 来处理 json。我在从 JSON 解码到层次结构的子类时遇到问题。

我遇到问题的代码是以下测试：

  test("FailingResponse - Conversion between case object and Json works") {
    val caseObject = FailingResponse("Some Error", StatusCodes.INTERNAL_ERROR)
    val jsonString = caseObject
      .asJson
      .printWith(Printer.noSpaces)

    decode[ValuationResponse](jsonString) must be(Right(caseObject))
  }

我希望能够解码到 ValuationResponse 的任何子类，因为在解码时我无法确定响应是 FailingResponse 还是 SuccessfulResponse。我希望解码器能够推断出它是什么类型的 ValuationReponse，对其进行解码并使其作为 "generic" ValuationResponse 可用。然后我可以用匹配案例或类似的东西来处理它以获得实际的特定类型。

相反，我在该测试中得到的是 DecodingFailure 错误。我做错了什么？

这是层次结构的代码：

sealed trait ValuationResponse {
  def statusCode: StatusCode
}

case class SuccessfulResponse(values: List[StockValuation], symbol: String, function: TimeSeriesType, statusCode: StatusCode) extends ValuationResponse

case class FailingResponse(reason: String, statusCode: StatusCode) extends ValuationResponse

case class ValuationRequest(function: TimeSeriesType = TIME_SERIES_INTRADAY, symbol: String, interval: IntraDayInterval = IntraDayIntervals.MIN_5)

object derivation {

  implicit val encodeResponse: Encoder[ValuationResponse] = Encoder.instance {
    case response@SuccessfulResponse(_, _, _, _) => response.asJson
    case response@FailingResponse(_, _) => response.asJson
  }
  implicit val decodeResponse: Decoder[ValuationResponse] =
    List[Decoder[ValuationResponse]](
      Decoder[SuccessfulResponse].widen,
      Decoder[FailingResponse].widen
    ).reduceLeft(_ or _)

  implicit val encodeRequest: Encoder[ValuationRequest] = Encoder.instance {
    case response@ValuationRequest(_, _, _) => response.asJson
  }
  implicit val decodeRequest: Decoder[ValuationRequest] =
    List[Decoder[ValuationRequest]](
      Decoder[ValuationRequest].widen
    ).reduceLeft(_ or _)
}

这些是它使用的枚举（是的，我知道有一个状态代码枚举是愚蠢的啊哈）：

sealed abstract class TimeSeriesType(val text: String) extends EnumEntry {}

sealed abstract class IntraDayInterval(val text: String) extends EnumEntry {}

object TimeSeriesFunctions extends Enum[TimeSeriesType] with CirceEnum[TimeSeriesType] {
  val values: immutable.IndexedSeq[TimeSeriesType] = findValues

  case object TIME_SERIES_INTRADAY extends TimeSeriesType("TIME_SERIES_INTRADAY")

  case object TIME_SERIES_DAILY extends TimeSeriesType("TIME_SERIES_DAILY")

  case object TIME_SERIES_WEEKLY extends TimeSeriesType("TIME_SERIES_WEEKLY")

  case object TIME_SERIES_MONTHLY extends TimeSeriesType("TIME_SERIES_MONTHLY")

}

object IntraDayIntervals extends Enum[IntraDayInterval] with CirceEnum[IntraDayInterval] {
  val values: immutable.IndexedSeq[IntraDayInterval] = findValues

  case object MIN_1 extends IntraDayInterval("1min")

  case object MIN_5 extends IntraDayInterval("5min")

  case object MIN_15 extends IntraDayInterval("15min")

  case object MIN_30 extends IntraDayInterval("30min")

  case object MIN_60 extends IntraDayInterval("60min")

}

object StatusCodes extends Enum[StatusCode] with CirceEnum[StatusCode] {
  val values: immutable.IndexedSeq[StatusCode] = findValues

  case object SUCCESS extends StatusCode(200)

  case object INTERNAL_ERROR extends StatusCode(500)

  case object REQUESTER_ERROR extends StatusCode(400)

}

Answer 1

当我测试你的代码时做了一些修改（删除了一些东西以使代码编译更容易）：

  type StatusCode = Int
  sealed trait ValuationResponse {
    def statusCode: StatusCode
  }

  case class SuccessfulResponse(succ: String, statusCode: StatusCode) extends ValuationResponse

  case class FailingResponse(reason: String, statusCode: StatusCode) extends ValuationResponse

  case class ValuationRequest(test: String)

  object derivation {

    implicit val encodeResponse: Encoder[ValuationResponse] = Encoder.instance {
      case response@SuccessfulResponse(_, _) => response.asJson
      case response@FailingResponse(_, _) => response.asJson
    }
    implicit val decodeResponse: Decoder[ValuationResponse] =
      List[Decoder[ValuationResponse]](
        Decoder[SuccessfulResponse].widen,
        Decoder[FailingResponse].widen
      ).reduceLeft(_ or _)

    implicit val encodeRequest: Encoder[ValuationRequest] = Encoder.instance {
      case response@ValuationRequest(_) => response.asJson
    }
    implicit val decodeRequest: Decoder[ValuationRequest] =
      List[Decoder[ValuationRequest]](
        Decoder[ValuationRequest].widen
      ).reduceLeft(_ or _)
  }

  val caseObject = FailingResponse("Some Error", 200)
  val jsonString = caseObject
        .asJson
        .printWith(Printer.noSpaces)

我得到了

@ decode[ValuationResponse](jsonString)
res21: Either[Error, ValuationResponse] = Left(DecodingFailure(CNil, List()))

但是，当我从对象中导入隐式时

@ import derivation._
import derivation._

@ decode[ValuationResponse](jsonString)
res23: Either[Error, ValuationResponse] = Right(FailingResponse("Some Error", 200))

事实上，默认情况下，Circe 使用区分字段来区分总和类型成员。如果你不导入 derivation object:

，你可以看到你的值被编码成什么

@ {
  val jsonString = (caseObject : ValuationResponse)
        .asJson
        .printWith(Printer.noSpaces)
  }
jsonString: String = "{\"FailingResponse\":{\"reason\":\"Some Error\",\"statusCode\":200}}"

因此，您在解码您的案例时使用了自动派生的编解码器 class - 如果您删除了 import io.circe.generic.auto._，当您尝试解码内容而不导入您自己编写的代码时，您的编译将失败（import derivation._).

为避免以后出现此类情况：

不要在编解码器使用站点上的生产中导入 io.circe.generic.auto._ - 它可以为应该使用您的 hand-written/manually-derived 编解码器的案例 class 派生新的编解码器（这会导致像这样的错误）
更喜欢 io.circe.generic.semiauto._ 在你需要的地方召唤派生的编解码器（而不是 Decoder[A] 写 deriveDecoder[A]）
将您的半自动派生编解码器以及手写编解码器放入您为其派生编解码器的类型的伴生对象中（如果可能）- 这样就无需在每次需要时手动导入它们

  import io.circe.generic.semiauto._

  sealed trait ValuationResponse ...
  object ValuationResponse {
    implicit val decodeResponse: Decoder[ValuationResponse] =
      List[Decoder[ValuationResponse]](
        deriveDecoder[SuccessfulResponse].widen,
        deriveDecoder[FailingResponse].widen
      ).reduceLeft(_ or _)
  }

顺便说一句。使用 semiauto 还可以帮助您避免其他错误，例如您的代码中的 cyclic-dependency on initialization of your implicit：

@ derivation.decodeRequest.decodeJson("test".asJson)
java.lang.NullPointerException
  ammonite.$sess.cmd7$.<clinit>(cmd7.sc:1)

但如果它使用 deriveDecoder:

implicit val decodeRequest: Decoder[ValuationRequest] =
    List[Decoder[ValuationRequest]](
      deriveDecoder[ValuationRequest].widen
    ).reduceLeft(_ or _)

你会得到：

@ val decodeRequests: Decoder[ValuationRequest] =
      List[Decoder[ValuationRequest]](
        io.circe.generic.semiauto.deriveDecoder[ValuationRequest].widen
      ).reduceLeft(_ or _)
decodeRequests: Decoder[ValuationRequest] = io.circe.generic.decoding.DerivedDecoder$$anon@30570f04

@ decodeRequests.decodeJson("test".asJson)
res9: Decoder.Result[ValuationRequest] = Left(DecodingFailure(Attempt to decode value on failed cursor, List(DownField(test))))

无法在 Scala 中使用 Circe 解码子类

Can't decode subclasses using Circe in Scala

json

scala

enums

traits

circe