Jouer Générique JSON Formater

Question

J'ai une application scala et une classe de cas comme celui -

case class SR(
    systemId: Option[String] = None, 
    x: Map[Timestamp, CaseClass1] = Map.empty, 
    y: Map[Timestamp, CaseClass2] = Map.empty, 
    y: Map[Timestamp, CaseClass3] = Map.empty 
) 

Maintenant, je dois fournir une lecture implicite et écrire le format JSON pour les propriétés x, y, z pour la classe SR cas comme -

implicit val mapCMPFormat = new Format[Map[Timestamp, CaseClass1]] { 
    def writes(obj: Map[Timestamp, CaseClass1]): JsValue = 
     JsArray(obj.values.toSeq.map(Json.toJson(_))) 
    def reads(jv: JsValue): JsResult[Map[Timestamp, CaseClass1]] = jv.validate[scala.collection.Seq[CaseClass1]] match { 
     case JsSuccess(objs, path) => JsSuccess(objs.map(obj => obj.dataDate.get -> obj).toMap, path) 
     case err: JsError => err 
    } 
    } 

et ainsi de même pour Y et Z, et à l'avenir, je vais ajouter beaucoup d'autres propriétés comme x, y, z en classe SR cas et besoin de fournir les formateurs.

Alors, est-ce que je peux obtenir un formateur générique qui prendra soin de tous les types?

Answer 1

A ma connaissance, un moyen simple d'y parvenir ne cependant, de créer existe pas, un lecteur « par défaut » pour chaque objet ne doit pas être difficile à faire, quelque chose comme:

case class VehicleColorForAdd(
    name: String, 
    rgb: String 
) 

object VehicleColorForAdd { 
    implicit val jsonFormat: Format[VehicleColorForAdd] = Json.formats[VehicleColorForAdd] 
} 

De cette façon, vous avoir accès à l'implicite en utilisant simplement l'objet, de sorte que vous pourriez avoir d'autres objets qui contient cet objet sans problème:

case class BiggerModel(
    vehicleColorForAdd: VehicleColorForAdd 
) 

object BiggerModel{ 
    implicit val jsonFormat: Format[BiggerModel] = Json.format[BiggerModel] 
} 

Malheureusement, vous devez le faire pour chaque type de classe, mais vous pouvez « étendre » jouer des convertisseurs avec les vôtres, par exemple, ce sont quelques-uns de mes lecteurs par défaut:

package common.json 

import core.order.Order 
import org.joda.time.{ DateTime, LocalDateTime } 
import org.joda.time.format.DateTimeFormat 
import core.promotion.{ DailySchedule, Period } 
import play.api.libs.functional.syntax._ 
import play.api.libs.json.Reads._ 
import play.api.libs.json._ 
import play.api.libs.json.{ JsError, JsPath, JsSuccess, Reads } 

import scala.language.implicitConversions 

/** 
* General JSon readers and transformations. 
*/ 
object JsonReaders { 

    val dateTimeFormat = "yyyy-MM-dd HH:mm:ss" 

    class JsPathHelper(val path: JsPath) { 
    def readTrimmedString(implicit r: Reads[String]): Reads[String] = Reads.at[String](path)(r).map(_.trim) 

    def readUpperString(implicit r: Reads[String]): Reads[String] = Reads.at[String](path)(r).map(_.toUpperCase) 

    def readNullableTrimmedString(implicit r: Reads[String]): Reads[Option[String]] = Reads.nullable[String](path)(r).map(_.map(_.trim)) 
    } 

    implicit val localDateTimeReader: Reads[LocalDateTime] = Reads[LocalDateTime]((js: JsValue) => 
    js.validate[String].map[LocalDateTime](dtString => 
     LocalDateTime.parse(dtString, DateTimeFormat.forPattern(dateTimeFormat)))) 

    val localDateTimeWriter: Writes[LocalDateTime] = new Writes[LocalDateTime] { 
    def writes(d: LocalDateTime): JsValue = JsString(d.toString(dateTimeFormat)) 
    } 

    implicit val localDateTimeFormat: Format[LocalDateTime] = Format(localDateTimeReader, localDateTimeWriter) 

    implicit val dateTimeReader: Reads[DateTime] = Reads[DateTime]((js: JsValue) => 
    js.validate[String].map[DateTime](dtString => 
     DateTime.parse(dtString, DateTimeFormat.forPattern(dateTimeFormat)))) 

    implicit def toJsPathHelper(path: JsPath): JsPathHelper = new JsPathHelper(path) 

    val defaultStringMax: Reads[String] = maxLength[String](255) 

    val defaultStringMinMax: Reads[String] = minLength[String](1) andKeep defaultStringMax 

    val rgbRegex: Reads[String] = pattern("""^#([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})$""".r, "error.invalidRGBPattern") 

    val plateRegex: Reads[String] = pattern("""^[\d\a-zA-Z]*$""".r, "error.invalidPlatePattern") 

    val minOnlyWordsRegex: Reads[String] = minLength[String](2) keepAnd onlyWordsRegex 

    val positiveInt: Reads[Int] = min[Int](1) 

    val zeroPositiveInt: Reads[Int] = min[Int](0) 

    val zeroPositiveBigDecimal: Reads[BigDecimal] = min[BigDecimal](0) 

    val positiveBigDecimal: Reads[BigDecimal] = min[BigDecimal](1) 

    def validLocalDatePeriod()(implicit reads: Reads[Period]) = 
    Reads[Period](js => reads.reads(js).flatMap { o => 
     if (o.startPeriod isAfter o.endPeriod) 
     JsError("error.startPeriodAfterEndPeriod") 
     else 
     JsSuccess(o) 
    }) 

    def validLocalTimePeriod()(implicit reads: Reads[DailySchedule]) = 
    Reads[DailySchedule](js => reads.reads(js).flatMap { o => 
     if (o.dailyStart isAfter o.dailyEnd) 
     JsError("error.dailyStartAfterDailyEnd") 
     else 
     JsSuccess(o) 
    }) 
} 

besoin Alors, vous n'importer cet objet pour avoir accès à tous ces convertisseurs implicites:

package common.forms 

import common.json.JsonReaders._ 
import play.api.libs.json._ 

/** 
* Form to add a model with only one string field. 
*/ 
object SimpleCatalogAdd { 

    case class Data(
    name: String 
) 

    implicit val dataReads: Reads[Data] = (__ \ "name").readTrimmedString(defaultStringMinMax).map(Data.apply) 
}