How to serialize objects from/to json in spray with defaultFormats? - json

Question

I've got a code that looks like that.
import akka.actor.{Props, ActorRef, Actor}
import akka.util.Timeout
import org.json4s.DefaultFormats
import spray.routing.HttpService
import spray.httpx.Json4sSupport
import scala.concurrent.Await
import scala.concurrent.duration._
import akka.pattern.ask
/**
* Created by mihaildoronin on 06.10.15.
*/
class ProcessesService() extends Actor with HttpService {
def actorRefFactory = context
def receive = runRoute(route)
val systemActor = context.actorOf(Props[SystemActor])
implicit val json4sFormats = DefaultFormats
implicit val timeout = Timeout(5 seconds)
val route = path("processes") {
get {
parameters('fromId.as[Int], 'count.as[Int]).as(GetProcessesCommand) { command =>
complete {
val response = Await.result(systemActor ? command, timeout.duration).asInstanceOf[CursoredResponse]
response
}
}
} ~
post {
entity(as[RegisterProcessCommand]) { command =>
complete {
val result = Await.result(systemActor ? command, timeout.duration).asInstanceOf[Long]
}
}
}
} ~
pathPrefix("processes" / IntNumber) { id =>
complete {
val process = Await.result(systemActor ? GetProcessCommand(id), timeout.duration).asInstanceOf[Process]
process
}
}
}
It gives me errors like that
Error:(28, 11) type mismatch;
found : CursoredResponse
required: spray.httpx.marshalling.ToResponseMarshallable
response
^
But in this tutorial a similar code seems to work. I've overridden json4sFormats and made them implicit, I'm using case classes, what am I missing here?
I'm new to scala and spray, so It's not clear to me.

Answer 1

For you class you should provide Marshaller and Unmarshaller. From Spray Json Tutorial:
import spray.json.DefaultJsonProtocol
import spray.httpx.unmarshalling._
import spray.httpx.marshalling._
and cast you CursoredResponse to Json
import MyJsonProtocol._
import spray.httpx.SprayJsonSupport._
import spray.util._
object CursoredResponseProtocol extends DefaultJsonProtocol {
implicit val CursoredResponseFormat = jsonFormat3(CursoredResponse)
}
Here's the reference:

Answer 2

I think you just need to mix spray.httpx.Json4sSupport into your class. So...
class ProcessesService() extends Actor with HttpService with Json4sSupport {
...
}
I originally provided a generic answer for an approach to using spray-json. But after re-reading, I realized I was answering the wrong question. I'll leave my original answer below in case anyone happens to find it useful.
My preferred approach is to create a trait that extends Spray's DefaultJsonProtocol and SprayJsonSupport. Inside of that, I create implicit references to RootJsonFormats for all of my case classes. Then I just mix that trait into the class or trait where my route is defined.
To me, it's the easiest way to keep things organized and supply the needed (un)marshaling functionality to my Spray routes, as well as other components where I use Spray client to integrate with HTTP-based service providers that produce and consume JSON.
Say you have an endpoint that returns a FooBar. Here's the case class we want to marshal to JSON:
case class FooBar(withNuts: Boolean = true, kingSize: Boolean = false)
We define a trait that contains the RootJsonFormat for our custom classes -- in this case a FooBar -- that will be able to read and write JSON
import spray.json.{RootJsonFormat, DefaultJsonProtocol}
import spray.httpx.SprayJsonSupport
trait MyAppJsonProtocol extends DefaultJsonProtocol with SprayJsonSupport {
implicit val FooBarFormat: RootJsonFormat[FooBar] = jsonFormat2(FooBar)
}
Then mix MyAppJsonProtocol into the route.
trait FooBarRoute extends HttpService with MyAppJsonProtocol {
implicit def executionContext = actorRefFactory.dispatcher
val fooRoute = {
(get & path("foobar")) {
complete(FooBar())
}
}
}
If you have additional classes that require (un)marshaling, simply add another implicit RootJsonFormat for each of those classes to your MyAppJsonProtocol trait.