How to write implicit Writes for case class having more than 22 fields

Question

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
)

For a case class like this, I need to write implicit json de- / serializer. I tried splitting the fields, and had a JSONFormat. But still I need implicit OWrited for using Json.obj(). I tried with play-json-extensions also. Any ideas?

Please check documentation at http://docs.scala-lang.org/overviews/core/value-classes.html — FaigB, Mar 09 '17 at 14:29
How value class can be used in this example? and how it will solve? — sowmiyaksr, Mar 09 '17 at 14:42

score 1 · Accepted Answer · answered Mar 09 '17 at 14:48

There's really 3 avenues for you to explore here:

Write out each class explicitly yourself (yes, tons of boilerplate.)
Do it with Macros or Shapeless.
Use someone's library who already did #2.

I like it when someone else does the work for me. So with that in mind, #3 seems like my preferred solution... And what would you know? Someone else did just that: play-json-derived-codecs. Since it uses Shapeless, it will be able to handle case classses of arbitrary size, not just those constrained by ProductN (1-22, depending on your version of Scala.)

+1 for someone else library. You also have [play-json-extensions](https://github.com/xdotai/play-json-extensions) that uses macros to do the work — vdebergue, Mar 09 '17 at 16:29

Setu Kumar Basak · Answer 2 · 2018-07-14T13:32:53.893

We can achieve without using play-json-extensions. Suppose we have a case class of more than 22 fields like below:

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

Now we will split and group the fields into some groups and write formats.

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

And finally merge all the formats into one format.

 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
    )))

We need to import function syntax like below:

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

Now, play can not serialize/deserialize optional and date fields. So, we need to write implicit formats for optional and date fields like below:

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
    }
  }

That's all we need to write Writes for case classes more than 22 fields.

You can read my article here..

How to write implicit Writes for case class having more than 22 fields

2 Answers2

Linked