斯卡拉 Circe。编码器类型 任意

Question

我正在尝试编码class ResponseResult为 json

case class ResponseResult (var Code : Int,
                 var Message: String,
                 var Data: Any )

var json = ResponseResult(1, "2", List(3,4,5)).asJson

我收到错误找不到参数编码器的隐式值：io.circe.Encoder[ResponseResult]

然后我创建编码器

object ResponseResult {
    implicit val encodeResult: Encoder[ResponseResult] =
        Encoder.forProduct3[ResponseResult, Int, String, Any]("Code", "Message", "Data") {
            case ResponseResult(c, m, d) => (c, m, d.toString)
        }
}

我收到错误找不到参数编码器的隐式值：编码器 [Any]

这是我的完整代码

import io.circe.Encoder
import io.circe.generic.auto._
import io.circe.syntax._

object a {
  case class ResponseResult (var Code : Int,
                             var Message: String,
                             var Data: Any )
  object ResponseResult {
    implicit val encodeResult: Encoder[ResponseResult] =
      Encoder .forProduct3[ResponseResult, Int, String, Any]("Code", "Message", "Data") {
        case ResponseResult(c, m, d) => (c, m, d.toString)
      }
  }

  def main(args: Array[String]): Unit = {
    var json = ResponseResult(1, "2", List(3,4,5)).asJson
  }
}

任何人都可以告诉我如何编码class ResponseResult。谢谢

Answer 1

好吧，你不能有Any类型的编解码器，就这么简单。

如果你想在那里传递一些值，序列化它并能够在以后反序列化它，你必须假设某种类型。您可以通过使用类型参数来推迟此假设：

case class ResponseResult[Data](Code : Int,
                                Message: String,
                                Data: Data)

并要求存在此类型参数的编码器：

object ResponseResult {
  implicit def encodeResult[Data: Encoder]: Encoder[ResponseResult[Data]] =
    Encoder.forProduct3[ResponseResult[Data], Int, String, Data]("Code", "Message", "Data") {
      case ResponseResult(c, m, d) => (c, m, d)
    }
}

然后你就可以像你想要的那样序列化数据

// inferred to ResponseResult[List[Int]]
val response = ResponseResult(1, "2", List(3,4,5))

// and Circe can generate codec for List[Int] automatically
// so it can now generate codec for ResponseResult[List[Int]]
val json = response.asJson