Question

这是一个简单的雀科服务器，使用circe作为解码器：

import com.twitter.finagle.http.RequestBuilder
import com.twitter.io.Buf
import io.circe.generic.auto._
import io.finch._
import io.finch.circe._

case class Test(myValue: Int)

val api = post("foo" :: body.as[Test]) { test: Test => Ok(test) }

val bodyPost = RequestBuilder()
  .url("http://localhost:8080/foo")
  .buildPost(Buf.Utf8("""{ "myValue" : 42 }"""))

api.toService.apply(bodyPost).onSuccess { response =>
  println(s"$response: ${response.contentString}")
}

// output: Response("HTTP/1.1 Status(200)"): {"myValue":42}

将myValue更改为Option即可使用，提供与上述代码相同的结果。但是，将其更改为scalaz.Maybe：

import scalaz.Maybe
case class Test(myValue: Maybe[Int])

结果：

响应（“HTTP / 1.1状态（400）”）：{“message”：“无法转换正文测试：CNil：El（DownField（myValue），true，false）。“}

我应该如何实现所需的编码器/解码器？

Answer 1

这是一种略有不同的方法：

import io.circe.{ Decoder, Encoder }
import scalaz.Maybe

trait ScalazInstances {
  implicit def decodeMaybe[A: Decoder]: Decoder[Maybe[A]] =
    Decoder[Option[A]].map(Maybe.fromOption)

  implicit def encodeMaybe[A: Encoder]: Encoder[Maybe[A]] =
    Encoder[Option[A]].contramap(_.toOption)
}

object ScalazInstances extends ScalazInstances

然后：

scala> import scalaz.Scalaz._, ScalazInstances._
import scalaz.Scalaz._
import ScalazInstances._

scala> import io.circe.parser.decode, io.circe.syntax._
import io.circe.parser.decode
import io.circe.syntax._

scala> Map("a" -> 1).just.asJson.noSpaces
res0: String = {"a":1}

scala> decode[Maybe[Int]]("1")
res1: Either[io.circe.Error,scalaz.Maybe[Int]] = Right(Just(1))

这种实现的主要优点（除了它更通用，甚至更简洁的事实）是它具有您通常期望的案例类中的可选成员的行为。例如，在您的实现中，以下输入失败：

scala> import io.circe.generic.auto._
import io.circe.generic.auto._

scala> case class Foo(i: Maybe[Int], s: String)
defined class Foo

scala> decode[Foo]("""{ "s": "abcd" }""")
res2: Either[io.circe.Error,Foo] = Left(DecodingFailure(Attempt to decode value on failed cursor, List(DownField(i))))

scala> decode[Foo]("""{ "i": null, "s": "abcd" }""")
res3: Either[io.circe.Error,Foo] = Left(DecodingFailure(Int, List(DownField(i))))

如果您使用上面的解码器只委托给Option解码器，那么它们会被解码为Empty：

scala> decode[Foo]("""{ "s": "abcd" }""")
res0: Either[io.circe.Error,Foo] = Right(Foo(Empty(),abcd))

scala> decode[Foo]("""{ "i": null, "s": "abcd" }""")
res1: Either[io.circe.Error,Foo] = Right(Foo(Empty(),abcd))

当然，您是否想要这种行为取决于您，但这是大多数人可能期望从Maybe编解码器中获得的。

脚注

我的解码器的一个缺点（在一些非常特殊的情况下）是它为每个成功解码的值实例化额外的Option。如果您非常关心分配（或者如果您只是对这些内容的工作方式感到好奇，这可能是一个更好的理由），您可以基于circe {{1}来实现自己的分配。 }：

decodeOption

import cats.syntax.either._ import io.circe.{ Decoder, DecodingFailure, Encoder, FailedCursor, HCursor } import scalaz.Maybe implicit def decodeMaybe[A](implicit decodeA: Decoder[A]): Decoder[Maybe[A]] = Decoder.withReattempt { case c: HCursor if c.value.isNull => Right(Maybe.empty) case c: HCursor => decodeA(c).map(Maybe.just) case c: FailedCursor if !c.incorrectFocus => Right(Maybe.empty) case c: FailedCursor => Left(DecodingFailure("[A]Maybe[A]", c.history)) }部分可以让我们将Decoder.withReattempt之类的内容解码为{}并按预期获得case class Foo(v: Maybe[Int])。这个名字有点令人困惑，但它真正的意思是＆＃34;即使最后一次操作失败也应用这个解码操作＆＃34;。在解析的背景下，例如像Foo(Maybe.empty)这样的案例类，最后一个操作是尝试在JSON对象中选择case class Foo(v: Maybe[Int])字段。如果没有"v"密钥，通常这就是故事的结尾 - 我们的解码器甚至无法应用，因为没有什么可以应用它。 "v"允许我们继续解码。

此代码非常低级，withReattempt和Decoder API的这些部分的设计效率高于用户友好性，但它仍然可以告诉您什么＆＃ 39，如果你盯着它，它会继续下去。如果上一个操作没有失败，我们可以检查当前的JSON值是否为空，如果是，则返回HCursor。如果不是，我们会尝试将其解码为Maybe.empty，如果成功，则将结果包装在A中。如果上一次操作失败，我们首先检查操作和最后一次焦点是否不匹配（由于一些奇怪的角落情况需要详细信息 - 请参阅我的提案here和链接的bug report详情）。如果他们不这样做，我们就会成功地成功。如果它们不匹配，我们就会失败。

同样，你几乎肯定不应该在Maybe.just上使用这个版本映射更清晰，更具前瞻性，而且效率稍差。但是，无论如何，理解Decoder[Option[A]]都很有用。

Answer 2

这是一个可能的实现：

implicit def encodeDecodeMaybe: Encoder[Maybe[Int]] with Decoder[Maybe[Int]] = new Encoder[Maybe[Int]] with Decoder[Maybe[Int]] {
    override def apply(a: Maybe[Int]): Json = Encoder.encodeInt.apply(a.getOrElse(0)) // zero if Empty
    override def apply(c: HCursor): Decoder.Result[Maybe[Int]] = Decoder.decodeInt.map(s => Just(s)).apply(c)
}

Circe解码器为scalaz.Maybe

2 个答案:

脚注