22 des champs de limite dans Scala 2.11 + Play Framework 2.3 Cas des classes et des fonctions

Nous avons également été la rupture de l'un de nos modèles en plusieurs classes de cas, mais cela a été rapidement devenir ingérable. Nous utilisons Slick que notre object relational mapper, et Slick 2.0 est livré avec un générateur de code que nous utilisons pour générer des classes (qui viennent avec appliquent des méthodes et une copie des constructeurs pour imiter des classes de cas) ainsi que les méthodes utilisées pour instancier les modèles de Json (nous ne génère pas automatiquement de méthodes pour convertir les modèles en Json parce que nous avons de trop nombreux cas particuliers à traiter). À l'aide de la Nappe générateur de code ne nécessite pas l'utilisation de la Nappe de votre object relational mapper.

Cela fait partie de l'entrée du générateur de code - cette méthode prend un JsObject et l'utilise soit pour instancier un nouveau modèle ou la mise à jour d'un modèle existant.

private def getItem(original: Option[${name}], json: JsObject, trackingData: TrackingData)(implicit session: scala.slick.session.Session): Try[${name}] = {
  preProcess("$name", columnSet, json, trackingData).flatMap(updatedJson => {
    ${indent(indent(indent(entityColumnsSansId.map(c => s"""val ${c.name}_Parsed = parseJsonField[${c.exposedType}](original.map(_.${c.name}), "${c.name}", updatedJson, "${c.exposedType}")""").mkString("\n"))))}
    val errs = Seq(${indent(indent(indent(indent(entityColumnsSansId.map(c => s"${c.name}_Parsed.map(_ => ())").mkString(", ")))))}).condenseUnit
    for {
      _ <- errs
      ${indent(indent(indent(indent(entityColumnsSansId.map(c => s"${c.name}_Val <- ${c.name}_Parsed").mkString("\n")))))}
    } yield {
      original.map(_.copy(${entityColumnsSansId.map(c => s"${c.name} = ${c.name}_Val").mkString(", ")}))
        .getOrElse(${name}.apply(id = None, ${entityColumnsSansId.map(c => s"${c.name} = ${c.name}_Val").mkString(", ")}))
    }
  })
}

Par exemple, avec notre ActivityLog modèle de ce produit le code suivant. Si "original" n'est alors ce qui est appelé à partir d'un "createFromJson" méthode et on instancie un nouveau modèle; si "original" est Certains(activityLog) alors celui-ci est appelé à partir d'un "updateFromJson" méthode et de nous mettre à jour le modèle existant. Le "condenseUnit" méthode appelée sur le "val tre = ..." ligne dure Seq[Essayer[Unité]] et produit un essai[Unité]; si la Seq a des erreurs, puis l'Essayer[Unité] concatène les messages d'exception. Le parseJsonField et parseField méthodes ne sont pas générées - ils sont référencés dans le code généré.

private def parseField[T](name: String, json: JsObject, tpe: String)(implicit r: Reads[T]): Try[T] = {
Try((json \ name).as[T]).recoverWith {
case e: Exception => Failure(new IllegalArgumentException("Failed to parse " + Json.stringify(json \ name) + " as " + name + " : " + tpe))
}
}
def parseJsonField[T](default: Option[T], name: String, json: JsObject, tpe: String)(implicit r: Reads[T]): Try[T] = {
default match {
case Some(t) => if(json.keys.contains(name)) parseField(name, json, tpe)(r) else Try(t)
case _ => parseField(name, json, tpe)(r)
}
}
private def getItem(original: Option[ActivityLog], json: JsObject, trackingData: TrackingData)(implicit session: scala.slick.session.Session): Try[ActivityLog] = {
preProcess("ActivityLog", columnSet, json, trackingData).flatMap(updatedJson => {
val user_id_Parsed = parseJsonField[Option[Int]](original.map(_.user_id), "user_id", updatedJson, "Option[Int]")
val user_name_Parsed = parseJsonField[Option[String]](original.map(_.user_name), "user_name", updatedJson, "Option[String]")
val item_id_Parsed = parseJsonField[Option[String]](original.map(_.item_id), "item_id", updatedJson, "Option[String]")
val item_item_type_Parsed = parseJsonField[Option[String]](original.map(_.item_item_type), "item_item_type", updatedJson, "Option[String]")
val item_name_Parsed = parseJsonField[Option[String]](original.map(_.item_name), "item_name", updatedJson, "Option[String]")
val modified_Parsed = parseJsonField[Option[String]](original.map(_.modified), "modified", updatedJson, "Option[String]")
val action_name_Parsed = parseJsonField[Option[String]](original.map(_.action_name), "action_name", updatedJson, "Option[String]")
val remote_ip_Parsed = parseJsonField[Option[String]](original.map(_.remote_ip), "remote_ip", updatedJson, "Option[String]")
val item_key_Parsed = parseJsonField[Option[String]](original.map(_.item_key), "item_key", updatedJson, "Option[String]")
val created_at_Parsed = parseJsonField[Option[java.sql.Timestamp]](original.map(_.created_at), "created_at", updatedJson, "Option[java.sql.Timestamp]")
val as_of_date_Parsed = parseJsonField[Option[java.sql.Timestamp]](original.map(_.as_of_date), "as_of_date", updatedJson, "Option[java.sql.Timestamp]")
val errs = Seq(user_id_Parsed.map(_ => ()), user_name_Parsed.map(_ => ()), item_id_Parsed.map(_ => ()), item_item_type_Parsed.map(_ => ()), item_name_Parsed.map(_ => ()), modified_Parsed.map(_ => ()), action_name_Parsed.map(_ => ()), remote_ip_Parsed.map(_ => ()), item_key_Parsed.map(_ => ()), created_at_Parsed.map(_ => ()), as_of_date_Parsed.map(_ => ())).condenseUnit
for {
_ <- errs
user_id_Val <- user_id_Parsed
user_name_Val <- user_name_Parsed
item_id_Val <- item_id_Parsed
item_item_type_Val <- item_item_type_Parsed
item_name_Val <- item_name_Parsed
modified_Val <- modified_Parsed
action_name_Val <- action_name_Parsed
remote_ip_Val <- remote_ip_Parsed
item_key_Val <- item_key_Parsed
created_at_Val <- created_at_Parsed
as_of_date_Val <- as_of_date_Parsed
} yield {
original.map(_.copy(user_id = user_id_Val, user_name = user_name_Val, item_id = item_id_Val, item_item_type = item_item_type_Val, item_name = item_name_Val, modified = modified_Val, action_name = action_name_Val, remote_ip = remote_ip_Val, item_key = item_key_Val, created_at = created_at_Val, as_of_date = as_of_date_Val))
.getOrElse(ActivityLog.apply(id = None, user_id = user_id_Val, user_name = user_name_Val, item_id = item_id_Val, item_item_type = item_item_type_Val, item_name = item_name_Val, modified = modified_Val, action_name = action_name_Val, remote_ip = remote_ip_Val, item_key = item_key_Val, created_at = created_at_Val, as_of_date = as_of_date_Val))
}
})
}

les cas où des classes de cas peut ne pas fonctionner; l'un de ces cas est que les classes de cas ne peut pas prendre plus de 22 des champs. Un autre cas peut être que vous ne savez pas à propos de schéma à l'avance. Dans cette approche, les données est chargé comme un RDD de la ligne des objets. Le schéma est créé séparément à l'aide de la StructType et StructField objets qui représentent une table et un champ respectivement. Le schéma est appliqué à la ligne RDD pour créer DataFrame Spark.

J'ai essayé Informe "Automatique Typeclass Dérivation" en fonction de la solution proposée dans une autre réponse, et il n'a pas fonctionné pour l'un de nos modèles - jetait StackOverflow exceptions (cas de la classe avec ~30 domaines et 4 imbriqués les collections de classes avec 4 à 10 champs).

Donc, nous avons adopté cette solution et cela a fonctionné parfaitement. A confirmé que par l'écriture ScalaCheck test. De l'avis qu'il faut Jouer Json 2.4.