25

In Scala 2.10 apparently we're getting improved reflection.

How will this impact lift-json, jerkson, sjson and friends? Furthermore, can we expect in the not too distant future a built-in JSON language feature a la Groovy's excellent GSON in Scala?

The reason I ask is that I would dearly love to do:

case class Foo(a: String, b: Int, bar: Bar)
case class Bar(c: Int)
val foo = Foo("hey", 10, Bar(23))
val json = foo.toJson

without hoop jumping (i.e. boilerplate-ish prep work), even with arbitrarily complex object graphs. Perhaps I'm asking way too much, but one can always dream. Please shatter my 2.10 dreams or enlighten me as to what new avenues are opening with the highly anticipated release of Scala.Next

Also, in regard to case classes, it seems for validation/creation, scalaz validation is the go-to weapon of choice. It seems quite wonderful, acting as a safe proxy for object creation or as an error collector. As a Scewbie, however, I find scalaz somewhat challenging, and am resisting the F-ing dark side despite its obvious power ;-)

At any rate, the point here is, with 2.10 reflection we should be able to bind at runtime the fields from say, a form post, to the properties of a case class and perform basic validation based on property type alone (i.e. will not have to specify separate validation logic that specifies property foo must be a String since its type is already defined in the case class upon which we can now properly reflect)

So, brave new world cometh, or existing tools are the mainstay for the foreseeable future?

virtualeyes
  • 11,147
  • 6
  • 56
  • 91

3 Answers3

6

Forewords

Let me give a different solution that doesn't rely on any Java based library but only a pure Scala one.

Actually, as discussed in the comments of @Steve's results Play 2's scala version was using Jerkson for de/serializing Json to domain model. Where Jerkson is a DSL wrapper around a very good Java library for handling Json.

Answer

The above wasn't answering your question, since you were asking if it has been envisioned to used the reflection and the macro features of Scala 2.10 to ease this task!!!! By eliminating most boilerplates.

And it was a very good thought in fact because from the Play 2.1 version, the Json Scala API is not using Jerkson anymore but it's own mechanism.

This mechanism is in fact taking advantages of this new 2.10 version of Scala by introducing a brand new API based on two things:

  • a functional construction (Applicative Builder) adapted to be able to Read and Write Json or Domain instances. These builders are used to glue altogether combinators (for both read or write) in order to define coarse grained structured (like we do with Parser Combinators)
  • a bunch of macros that are able to discover which combinators are implicitly available and will construct complex ones for Case Classes (or at least types that have apply and unapply methods).

In the end of the day, here is what we could do by using this API:

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

case class Person(name: String, age: Int, lovesChocolate: Boolean)

implicit val personReads = Json.format[Person] //a format is a Reader and a Writer

//this format will be implicitly used by the following from/toJson functions
val person:JsResult[Person] = Json.fromJson(json) //JsResult is like JsSucces/JsError
val jsObject = Json.toJson(person)

code copied and adapted from: JSON Inception (Based on Scala 2.10 Macros)

A little note: the new API is even smart enough to be able to validate a "read" by accumulating errors...

References

There are a series of blogs from @mandubian that I'd recommend from here, because they are very enlightening it!

Final note

What is sad is that the modularization of Play 2... doesn't allow us to use this API alone! So, it should be used from the play lib as a whole :/ This might change in the future...

EDIT

And the future is getting closer now, since Pascal has this repo enabling us to use the play-json API.

So, one can use this repo until Play 2.2 will be released. Indeed, this version will be completely decoupled with several APIs like json or iteratees, and thus, we'll be able to use the playframework repo directly.

Andy Petrella
  • 4,345
  • 26
  • 29
  • +1, thanks for the update, maybe the dream is becoming reality ;-) – virtualeyes Jan 03 '13 at 02:26
  • Sorry for the delay... yes, it's coming. faster with the next 2.2 release when modularization will be done! Ans so this API should blow out and be available alone! – Andy Petrella Jan 14 '13 at 21:33
  • Regarding the final note. There is a [GitHub project](https://github.com/mandubian/play-json-alone) which provides the JSON library standalone. This will apparently be finalised for Play 2.2, but it can be already used today. – 0__ Jun 03 '13 at 09:54
  • The standalone Play 2.2 JSON API is now available (cf. [this answer](http://stackoverflow.com/a/20475410/1804173)) – bluenote10 Mar 19 '14 at 09:15
4

Jerkson handles your use case today!

Json.generate(foo)

It also supports streaming reads and writes which we use extensively in production.

Json.generate(foo, outputStream)
Json.parse[Foo](inputStream)

We originally used lift-json but its lack of streaming support for case classes made it unusable for reading and writing large json documents. Jerkson is also super fast and handles nested case classes perfectly.

Steve
  • 249
  • 1
  • 3
  • 3
    I will have to look again, last I checked Coda Hale, creator of Jerkson, had more or less abandoned the project (see Yammer exodus from Scala as well). For this reason, the ideal would be a built-in language feature that provided JSON utils out-of-the-box vs. relying on an external library that may or may not be maintained. – virtualeyes Mar 18 '12 at 15:54
  • 1
    Typesafe [chose Jerkson for Play 2.0](https://github.com/playframework/Play20/wiki/Scalajson), so it should be a safe choice for now. – Steve Mar 19 '12 at 01:45
  • 1
    There's also another add-on to jackson called [Jackson-Module-Scala](https://github.com/fasterxml/jackson-module-scala) that works very well. We use it extensively, and I believe we've fixed all of the kinks. – Nate Apr 19 '12 at 02:51
  • 2
    @Steve, it looks like Play is no longer using Jerkson. They build their interface directly on Jackson. Source: [Play Github project](https://github.com/playframework/Play20/tree/master/framework/src/play/src/main/scala/play/api/libs/json). – Kipton Barros Oct 20 '12 at 21:00
  • @Steve you're right that Play 2 was using jerkson up to the 2.0 version in its Scala API however, but for the 2.1 they've implemented their own as I said in my answer. – Andy Petrella Jan 03 '13 at 07:13
0

Made a blog post about that, check it out at http://pedrorijo.com/blog/scala-json/

Using case classes, and Play WS (already included in Play Framework) you case convert between json and case classes with a simple one-liner implicit

case class User(username: String, friends: Int, enemies: Int, isAlive: Boolean)

object User {
  implicit val userJsonFormat = Json.format[User]
}
pedrorijo91
  • 7,635
  • 9
  • 44
  • 82