Question

我有一个Java服务器，它创建如下消息：

@SerializedName("message")
private String _message;

@SerializedName("args")
private Object[] _args;

现在在我的Scala.js应用程序中，我想使用以下方式反序列化此消息：

case class Notification(message: String, args: String*)

implicit val messageDecoder: Decoder[Notification] = (c: HCursor) => {
  for {
    message  <- c.downField("message").as[String]
    args     <- c.downField("args").as[List[java.lang.Object]].map(_.toString)
  } yield {
    Notification(level, message, args)
  }
}

但是，Scala拒绝解码并显示以下错误：

implicit error;
[error] !I d: Decoder[List[Object]]
[error] Decoder.importedDecoder invalid because
[error] !I exported: Exported[Decoder[List[Object]]]
[error] Decoder.decodeCanBuildFrom invalid because
[error] !I d: Decoder[Object]
[error] ??Decoder.importedDecoder invalid because
[error]   !I exported: Exported[Decoder[Object]]
[error]
[error] Decoder.decodeList invalid because
[error] !I evidence$2: Decoder[Object]
[error] ??Decoder.importedDecoder invalid because
[error]   !I exported: Exported[Decoder[Object]]
[error]       args       <- 
        c.downField("args").as[List[Object]].map(_.toString)
[error]                                           ^
[error] one error found

关于如何对此进行解码的任何想法？我只需要对结果调用map(toString)。

编辑

尝试执行以下操作时：

args <- c.downField("args").as[Array[Any]].map(_.toString)

我收到以下错误：

diverging implicit expansion for type io.circe.Decoder[A]
[error] starting with value decodeString in object Decoder
[error]       args       <- 
     c.downField("args").as[Array[Any]].map(_.toString)
[error]                                           ^
[error] one error found

编辑2

args <- c.downField("args").as[Seq[String]].map(_.toString)

可以编译，但无法成功解析json（左）。

编辑3

发送的json的一个示例（在本例中为整数）：

{
  "message" : "{0} is smaller than {1}.",
  "args" : [
    1,
    2
  ]
}

java服务器还可以生成如下所示的JSON：

{
  "message" : "{0} is smaller than {1}. ({2})",
  "args" : [
    1,
    2,
    "Hello World!"
  ]
}

Answer 1

将其添加为另一个答案，以保持历史记录的清洁。

基本上，以下代码仅适用于当前json值，并使用其字符串表示形式。

case class Notification(message: String, args: String*)

object Notification {

  implicit val anyDecoder : Decoder[Any] =  Decoder.instance(c => {
      c.focus match {
          case Some(x) => Right(x)
          case None => Left(DecodingFailure("Could not parse", List()))
      }
  })

  implicit val messageDecoder: Decoder[Notification] = Decoder.instance(c => {
    for {
      message <- c.downField("message").as[String]
      args <- c.downField("args").as[List[Any]].map(_.toString)
    } yield {
      Notification(message, args)
    }
  })

}

测试用例是

val json = """
            {
                "message" : "Hello" ,
                "args"    : [ 2, 3.234, 4,"good", true  ]
            }
            """

println(decode[Notification](json))

Answer 2

假设您的args由Int和String组成，请查看这是否对您有用

case class Notification(message: String, args: String*)

object Notification {


  implicit val decodeIntOrString: Decoder[Either[Int, String]] =
    Decoder[Int].map(Left(_)).or(Decoder[String].map(Right(_)))

  implicit val messageDecoder: Decoder[Notification] = Decoder.instance(c => {
    for {
      message <- c.downField("message").as[String]
      args <- c.downField("args").as[List[Either[Int,String]]].map(_.toString)
    } yield {
      Notification(message, args)
    }
  })

}

这是测试用例

 val json = """
            {
                "message" : "Hello" ,
                "args"    : [ 2, 3, 4,"good"  ]
            }
            """

 println(decode[Notification](json))

我还要指出一个循环讨论https://github.com/circe/circe/issues/216，该讨论或多或少都涉及这个问题。我认为惯用的循环决策似乎是反序列化的类型。

Scala：使用circe.io解码Any []数组

2 个答案: