Question

http://github.com/spray/spray/spray-json” rel=“nofollow” 标题=“spray-json” >spray-json 图书馆以 toJson 方法扩展基本Scala类型。如果有基本类型的皮条客,我想将 > any 转换为 http://spray.github.com/spray/api/spray-json/#cc.spray.json.JsValue" rel=“noforpol” 标题=“JsValue”\\code> JsValue



import cc.spray._

val maybeJson1: PartialFunction[Any, JsValue] = {
  case x: BigDecimal => x.toJson
  case x: BigInt => x.toJson
  case x: Boolean => x.toJson
  case x: Byte => x.toJson
  case x: Char => x.toJson
  case x: Double => x.toJson
  case x: Float => x.toJson
  case x: Int => x.toJson
  case x: Long => x.toJson
  case x: Short => x.toJson
  case x: String => x.toJson
  case x: Symbol => x.toJson
  case x: Unit => x.toJson
}


最理想的是,我更喜欢这样(不可能)的东西:

def maybeJson2(any: Any): Option[JsValue] = {
  if (pimpExistsFor(any))
    Some(any.toJson)
  else
    None  
}


是否有办法做到这一点而不列举每一类已经丰富的东西?

Answer 1

有一种方法, 但是它需要一个 < em> lot < / em > 反射, 因此非常头疼。基本想法如下。 < code> DefaultJson 协议对象继承了含有包含 < code> write 方法的隐含物体的一堆特性。每一个都有一个访问器功能, 但是您不知道它的名称。基本上, 您会采取没有参数的 < em> all < / em > 方法, 并返回一个具有 < code> write 方法的天体, 该天体可以选择对象的类别, 并返回一个 < code> JsValue 。如果您找到一个精确的方法返回一个这样的类别, 请使用反省来称呼它。否则, 保释。

它看起来像 something like this (警告,未经测试):

def canWriteMe(writer: java.lang.Class[_], me: java.lang.Class[_]): 
  Option[java.lang.reflect.Method] =
{
  writer.getMethods.find(_.getName == "write").filter{ m =>
    classOf[JsValue].isAssignableFrom(m.getReturnType) && {
      val parm = m.getParameterTypes()
      m.length == 1 && parm(0).isAssignableFrom(me)
    }
  }
}
def maybeJson2(any: Any): Option[JsValue] = {
  val couldWork = {
    DefaultJsonProtocol.getClass.getMethods.
      filter(_.getParameterTypes.length==0).
      flatMap(m => canWriteMe(m.getReturnType, any.getClass).map(_ -> m))
  }
  if (couldWork.length != 1) None else {
    couldWork.headOption.map{ case (wrMeth, obMeth) =>
      val wrObj = obMeth.invoke(DefaultJsonProtocol)
      val answer = wrMeth.invoke(wrObj, any)
    }
  }
}

无论如何,你最好一步一步地将REPL中的 DefaultJson Protocol 类分开,找出如何可靠地识别定义作者的物体,然后从中取出 write 方法。

Answer 2

我不确定它是否适合你需要, 但这里有另一种方法, 很简单,而且类型安全。

如果您保留参数的类型( 而不是使用 < code> anyny ), 您可以依靠隐含参数分辨率在汇编时间找到正确的转换 :

def toJson[T:JsonFormat]( t: T ): JsValue = implicitly[JsonFormat[T]].write(t)

您不需要选项, 因为程序会在编译时失败, 如果您试图通过一个“ 无法” 的参数。

友情链接