Comment puis-je spécifier spray Type de Contenu d'en-tête de réponse?

Si vous voulez toujours utiliser un aérosol peut, alors vous avez deux options, selon que HttpResponse est une affaire de classe. La première est de passer d'une Liste explicite de type de contenu:

import spray.http.HttpHeaders._
import spray.http.ContentTypes._

def receive = {
    case HttpRequest(GET, Uri.Path("/something"), _, _, _) =>
      sender ! HttpResponse(entity = """{ "key": "value" }""", headers = List(`Content-Type`(`application/json`)))
  }

Ou, la deuxième méthode est d'utiliser une méthode withHeaders méthode:

def receive = {
    case HttpRequest(GET, Uri.Path("/something"), _, _, _) =>
      val response: HttpResponse = HttpResponse(entity = """{ "key": "value" }""")
      sender ! response.withHeaders(List(`Content-Type`(`application/json`)))
  }

Mais encore, comme jrudolph dit, il est beaucoup mieux d'utiliser un aérosol de routage, dans ce cas, il serait mieux:

def receive = runRoute {
    path("/something") {
      get {
        respondWithHeader(`Content-Type`(`application/json`)) {
          complete("""{ "key": "value" }""")
        }
      }
    }
  }

Mais pulvérisation rend encore plus facile et gère tous les (dé)sérialisation pour vous:

import spray.httpx.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._

def receive = runRoute {
  (path("/something") & get) {
    complete(Map("key" -> "value"))
  }
}

Dans ce cas reponse type sera mis à application/json par le jet lui-même.

Exemple complet pour mon commentaire:

class FullProfileServiceStack
  extends HttpServiceActor
     with ProfileServiceStack
     with ... {
  def actorRefFactory = context
  def receive = runRoute(serviceRoutes)
}

object Launcher extends App {
  import Settings.service._
  implicit val system = ActorSystem("Profile-Service")
  import system.log

  log.info("Starting service actor")
  val handler = system.actorOf(Props[FullProfileServiceStack], "ProfileActor")

  log.info("Starting Http connection")
  IO(Http) ! Http.Bind(handler, interface = host, port = port)
}

OriginalL'auteur 4lex1v

Au cours des dernières version de Pulvérisation (1.2.4 /1.3.4), vous souhaiterez peut-être utiliser respondWithMediaType. Voici l'exemple de la documentation :

val route =
  path("foo") {
    respondWithMediaType(`application/json`) {
      complete("[]") //marshalled to `text/plain` here
    }
  }

Noter que bien que cela remplace l'en-tête HTTP de la valeur, elle n'annule pas la marshaller utilisé pour la sérialisation de votre contenu sur le fil.

Donc à l'aide d'une récente spray avec vaporisateur, le routage, l'original, le code devrait ressembler à :

def receive = runRoute {
  path("/something") {
    get {
      respondWithMediaType(`application/json`) {
        complete("""{ "key": "value" }""")
      }
    }
  }
}

OriginalL'auteur Jean