CAVEATs

Question

我对反射没有太大的兴趣，这个答案在某些情况下使用无形状的作品（但似乎有很多边缘情况）Shapeless code to convert Map[String, Any] to case class cannot handle optional substructures

有人知道只有一个LOC才能做到这一点的好库吗？

Answer 1

我找到了使用Spray Json进行清理的合理方法

首先，我们定义一种从JsObject到Map[String, Any]的方法

def mapToJsObject(map: Map[String, Any]): JsObject =
  JsObject(fields = map.mapValues(anyToJsValue))

def anyToJsValue(any: Any): JsValue = any match {
  case n: Int => JsNumber(n)
  case n: Long => JsNumber(n)
  case n: Double => JsNumber(n)
  case s: String => JsString(s)
  case true => JsTrue
  case false => JsFalse
  case null | None => JsNull
  case list: List[_] => JsArray(list.map(anyToJsValue).toVector)
  case Some(any) => anyToJsValue(any)
  case map: Map[String, Any] => mapToJsObject(map)
}

然后，只要我们在范围内具有隐式convertTo，就可以使用JsonFormat

case class Address(street: String, zip: Int)
case class Person(name: String, address: Address)

implicit val addressFormat = jsonFormat2(Address.apply)
implicit val personFormat = jsonFormat2(Person.apply)

"Convert Person example map to Person JsObject" in {
  JsonUtils.mapToJsObject(
    Map(
      "name" -> "Tom",
      "address" -> Map("street" -> "Jefferson st", "zip" -> 10000)
    )
  ).convertTo[Person] must_=== Person("Tom", Address("Jefferson st", 10000))
}

CAVEATs

Spray json仅具有开箱即用的jsonFormat，最多可包含22个字段！

无法处理任何自定义类型，例如java.sql.Timestamp，因为这不是JSON类型。

Answer 2

使用杰克逊：

libraryDependencies += "com.fasterxml.jackson.core" % "jackson-databind" % "2.9.8"
libraryDependencies += "com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.9.8"

case class Foo(a: List[Int], b: Option[Double])
case class Bar(c: Int, d: String, e: Foo)

val mapper = new ObjectMapper().registerModule(DefaultScalaModule)
println(mapper.convertValue(Map(
  "c" -> 3, 
  "d" -> "foo", 
  "e" -> Map("a" -> List(1, 2))), classOf[Bar]))

输出：Bar(3,foo,Foo(List(1, 2),None))

Answer 3

我们可以使用circe

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


def mapToJson(map: Map[String, Any]): Json =
    map.mapValues(anyToJson).asJson

  def anyToJson(any: Any): Json = any match {
    case n: Int => n.asJson
    case n: Long => n.asJson
    case n: Double => n.asJson
    case s: String => s.asJson
    case true => true.asJson
    case false => false.asJson
    case null | None => None.asJson
    case list: List[_] => list.map(anyToJson).asJson
    case list: Vector[_] => list.map(anyToJson).asJson
    case Some(any) => anyToJson(any)
    case map: Map[String, Any] => mapToJson(map)
  }

def mapToCaseClass[T : Decoder](map: Map[String, Any]): T = mapToJson(map).as[T].right.get

然后，如果我们有任何不是原始类型的类型，我们只需将它们与可以将该类型编码/解码为原始类型的编码器/解码器对一起添加到anyToJson中即可。

例如我们可以用java.sql.Timestamp代表Long，然后

import cats.syntax.either._

  import io.circe.Decoder
  import io.circe.Encoder

  implicit val decodeTimestamp: Decoder[Timestamp] = Decoder.decodeLong.emap(long =>
    Either.catchNonFatal(new Timestamp(long)).leftMap(_ => "Timestamp")
  )

implicit val encodeTimestamp: Encoder[Timestamp] = Encoder.encodeLong.contramap[Timestamp](_.getTime)

，我们需要将行添加到anyToJson

case n: Timestamp => n.asJson

如何使用Scala中的任何库将可能嵌套的通用Map [String，Any]转换为case类？

3 个答案:

CAVEATs