将案例类表示为 JSON 数组
首先要注意的是 circe-shapes 模块为 Shapeless 提供了实例HList
使用数组表示形式,就像我们想要用于案例类的数组表示形式一样。例如:
scala> import io.circe.shapes._
import io.circe.shapes._
scala> import shapeless._
import shapeless._
scala> ("foo" :: 1 :: List(true, false) :: HNil).asJson.noSpaces
res4: String = ["foo",1,[true,false]]
…Shapeless 本身提供了案例类和案例类之间的通用映射HList
s。我们可以将这两者结合起来以获得我们想要的案例类的通用实例:
import io.circe.{ Decoder, Encoder }
import io.circe.shapes.HListInstances
import shapeless.{ Generic, HList }
trait FlatCaseClassCodecs extends HListInstances {
implicit def encodeCaseClassFlat[A, Repr <: HList](implicit
gen: Generic.Aux[A, Repr],
encodeRepr: Encoder[Repr]
): Encoder[A] = encodeRepr.contramap(gen.to)
implicit def decodeCaseClassFlat[A, Repr <: HList](implicit
gen: Generic.Aux[A, Repr],
decodeRepr: Decoder[Repr]
): Decoder[A] = decodeRepr.map(gen.from)
}
object FlatCaseClassCodecs extends FlatCaseClassCodecs
进而:
scala> import FlatCaseClassCodecs._
import FlatCaseClassCodecs._
scala> Cake("cherry", 100).asJson.noSpaces
res5: String = ["cherry",100]
scala> Hat("cowboy", "felt", "brown").asJson.noSpaces
res6: String = ["cowboy","felt","brown"]
请注意,我正在使用io.circe.shapes.HListInstances
将 circe-shapes 所需的实例与自定义案例类实例捆绑在一起,以最大程度地减少用户必须导入的内容数量(无论是出于人体工程学问题还是为了缩短编译时间) 。
对 ADT 的通用表示进行编码
这是一个很好的第一步,但它并没有给我们带来我们想要的表现Item
本身。为此,我们需要一些更复杂的机制:
import io.circe.{ JsonObject, ObjectEncoder }
import shapeless.{ :+:, CNil, Coproduct, Inl, Inr, Witness }
import shapeless.labelled.FieldType
trait ReprEncoder[C <: Coproduct] extends ObjectEncoder[C]
object ReprEncoder {
def wrap[A <: Coproduct](encodeA: ObjectEncoder[A]): ReprEncoder[A] =
new ReprEncoder[A] {
def encodeObject(a: A): JsonObject = encodeA.encodeObject(a)
}
implicit val encodeCNil: ReprEncoder[CNil] = wrap(
ObjectEncoder.instance[CNil](_ => sys.error("Cannot encode CNil"))
)
implicit def encodeCCons[K <: Symbol, L, R <: Coproduct](implicit
witK: Witness.Aux[K],
encodeL: Encoder[L],
encodeR: ReprEncoder[R]
): ReprEncoder[FieldType[K, L] :+: R] = wrap[FieldType[K, L] :+: R](
ObjectEncoder.instance {
case Inl(l) => JsonObject("tag" := witK.value.name, "contents" := (l: L))
case Inr(r) => encodeR.encodeObject(r)
}
)
}
这告诉我们如何对实例进行编码Coproduct
,Shapeless 使用它作为 Scala 中密封特征层次结构的通用表示。这些代码一开始可能会令人生畏,但这是一种非常常见的模式,如果您花费大量时间使用 Shapeless,您会认识到此代码的 90% 本质上是样板文件,您在像这样归纳构建实例时会看到它们。
解码这些联产品
解码实现甚至有点差,但遵循相同的模式:
import io.circe.{ DecodingFailure, HCursor }
import shapeless.labelled.field
trait ReprDecoder[C <: Coproduct] extends Decoder[C]
object ReprDecoder {
def wrap[A <: Coproduct](decodeA: Decoder[A]): ReprDecoder[A] =
new ReprDecoder[A] {
def apply(c: HCursor): Decoder.Result[A] = decodeA(c)
}
implicit val decodeCNil: ReprDecoder[CNil] = wrap(
Decoder.failed(DecodingFailure("CNil", Nil))
)
implicit def decodeCCons[K <: Symbol, L, R <: Coproduct](implicit
witK: Witness.Aux[K],
decodeL: Decoder[L],
decodeR: ReprDecoder[R]
): ReprDecoder[FieldType[K, L] :+: R] = wrap(
decodeL.prepare(_.downField("contents")).validate(
_.downField("tag").focus
.flatMap(_.as[String].right.toOption)
.contains(witK.value.name),
witK.value.name
)
.map(l => Inl[FieldType[K, L], R](field[K](l)))
.or(decodeR.map[FieldType[K, L] :+: R](Inr(_)))
)
}
一般来说,我们的逻辑会涉及更多一点Decoder
实现,因为每个解码步骤都可能失败。
我们的 ADT 代表
现在我们可以将它们组合在一起:
import shapeless.{ LabelledGeneric, Lazy }
object Derivation extends FlatCaseClassCodecs {
implicit def encodeAdt[A, Repr <: Coproduct](implicit
gen: LabelledGeneric.Aux[A, Repr],
encodeRepr: Lazy[ReprEncoder[Repr]]
): ObjectEncoder[A] = encodeRepr.value.contramapObject(gen.to)
implicit def decodeAdt[A, Repr <: Coproduct](implicit
gen: LabelledGeneric.Aux[A, Repr],
decodeRepr: Lazy[ReprDecoder[Repr]]
): Decoder[A] = decodeRepr.value.map(gen.from)
}
这看起来与我们的定义非常相似FlatCaseClassCodecs
上面的想法是相同的:我们通过构建这些数据类型的通用表示的实例来定义我们的数据类型(案例类或 ADT)的实例。请注意,我正在扩展FlatCaseClassCodecs
,再次最大限度地减少用户的进口。
行动中
现在我们可以像这样使用这些实例:
scala> import Derivation._
import Derivation._
scala> item1.asJson.noSpaces
res7: String = {"tag":"Cake","contents":["cherry",100]}
scala> item2.asJson.noSpaces
res8: String = {"tag":"Hat","contents":["cowboy","felt","brown"]}
……这正是我们想要的。最好的部分是,这适用于 Scala 中的任何密封特征层次结构,无论它有多少个案例类或这些案例类有多少个成员(尽管一旦您进入数十个其中之一,编译时间就会开始受到影响) ),假设所有成员类型都有 JSON 表示形式。