如何写超过22个字段的case class implicit

case class Foo(
    _1:Int,_2:Int,_3:Int,_4:Int,_5:Int, 
    _21:Int,_22:Int,_23:Int,_24:Int,_25:Int, 
    _31:Int,_32:Int,_33:Int,_34:Int,_35:Int, 
    _41:Int,_42:Int,_43:Int,_44:Int,_45:Int, 
    _51:Int,_52:Int,_53:Int,_54:Int,_55:Int 
)

对于这样的案例类，我需要编写隐式json de-/serializer。我尝试拆分字段，并有一个JSONFormat。但仍然需要使用Json.obj（）的隐式OWrited。我也尝试过使用play-json-extensions。有任何想法吗？如何写超过22个字段的case class implicit

来源

2017-03-09 sowmiyaksr

您是否尝试过价值班？ – FaigB

值类？抱歉。你能解释一下吗？ – sowmiyaksr

请检查http://docs.scala-lang.org/overviews/core/value-classes.html – FaigB

有真的3种途径为您探索这里：

写出每个类明确自己（是的，吨的样板。）
与宏或Shapeless做吧。
使用已经做过＃2的人的图书馆。

我喜欢当别人为我工作。所以，考虑到这一点，＃3似乎是我的首选解决方案......你会知道什么？其他人就是这样做的：play-json-derived-codecs。由于它使用Shapeless，它将能够处理任意大小的案例分类，而不仅仅是受ProductN限制的那些（1-22，取决于您的Scala版本）。

来源

2017-03-09 14:48:18 wheaties

+1为其他人库。你还有[play-json-extensions]（https://github.com/xdotai/play-json-extensions）使用宏来完成工作 – vdebergue

我们可以在不使用play-json-extensions的情况下实现。假设我们有一个案例类超过22场的象下面这样：

case class Foo(
    A: Int, 
    B: Option[Int], 
    C: String, 
    D: Option[String], 
    E: Seq[String], 
    F: Date 
    more fields.. 
)

现在我们将拆分和组领域为若干组，编写格式。

val fooFormat1: OFormat[(Int, Option[Int], String)] = 
    ((__ \ "A").format[Long] 
     ~ (__ \ "B").format[Option[Long]] 
     ~ (__ \ "C").format[Option[Long]]).tupled 


val fooFormat2: OFormat[(Option[String], Seq[String], Date)] = 
    ((__ \ "D").format[Long] 
     ~ (__ \ "E").format[Option[Long]] 
     ~ (__ \ "F").format[Option[Long]]).tupled

最后将所有格式合并为一种格式。

implicit val fooFormat: Format[Foo] = (fooFormat1 ~ fooFormat2)({ 
    case ((a, b, c), (d, e, f)) => 
     new Foo(a, b, c, d, e, f) 
    }, (foo: Foo) => ((
    foo.A, 
    foo.B, 
    foo.C 
), (
     foo.D, 
     foo.E, 
     foo.F 
    )))

我们需要导入函数的语法象下面这样：

import play.api.libs.functional.syntax._

现在，玩不能序列化/反序列化可选和日期字段。所以，我们需要编写可选和日期字段格式的隐象下面这样：

implicit object DateFormat extends Format[java.util.Date] { 
    val format = new java.text.SimpleDateFormat("yyyy-MM-dd") 
    def reads(json: JsValue): JsResult[java.util.Date] = JsSuccess(format.parse(json.as[String])) 
    def writes(date: java.util.Date): JsString = JsString(format.format(date)) 
    } 

implicit def optionFormat[T: Format]: Format[Option[T]] = new Format[Option[T]] { 
    override def reads(json: JsValue): JsResult[Option[T]] = json.validateOpt[T] 

    override def writes(o: Option[T]): JsValue = o match { 
     case Some(t) => implicitly[Writes[T]].writes(t) 
     case None => JsNull 
    } 
    }

这就是我们需要写写的情况下，班多领域。

来源

2017-09-08 06:14:21

如何写超过22个字段的case class implicit

回答

相关问题