Biblioteca cliente HTTP simple y concisa para Scala

Necesito una biblioteca cliente HTTP madura que sea idiomática para scala, concisa en el uso, semántica simple. Miré el HTTP Apache y el Scala Dispatch y numerosas bibliotecas nuevas que prometen una envoltura idiomática de Scala. El cliente HTTP Apache ciertamente exige verbosidad, mientras que Dispatch se confunde fácilmente.

¿Qué es un cliente HTTP adecuado para el uso de Scala?

Recientemente comencé a usar Dispatch , un poco arcano (gran introducción general, grave falta de documentos detallados basados ​​en escenarios / casos de uso). Dispatch 0.9.1 es una envoltura de Scala alrededor del Async Http Client de Ning ; para comprender completamente lo que está sucediendo requiere presentarse a esa biblioteca. En la práctica, lo único que realmente tenía que mirar era el RequestBuilder : todo lo demás encajaba muy bien en mi comprensión de HTTP.

Le doy a la versión 0.9 un sólido pulgar hacia arriba (¡hasta ahora!) Para hacer el trabajo de manera muy simple ... una vez que supere la curva de aprendizaje inicial.

El "constructor" Http de Dispatch es inmutable y parece funcionar bien en un entorno con subprocesos. Aunque no puedo encontrar nada en los documentos que indique que es seguro para subprocesos; la lectura general de la fuente sugiere que sí.

Tenga en cuenta que los RequestBuilder son mutables y, por lo tanto, NO son seguros para subprocesos.

Aquí hay algunos enlaces adicionales que me han resultado útiles:

• No puedo encontrar un enlace de ScalaDoc para la versión 0.9. *, Así que busco el código fuente de la versión 0.9. * ;

• ScalaDoc para la versión 0.8 ; una bestia sustancialmente diferente (hoy) que 0.9.

• La tabla "periódica" de operadores, también relacionada con 0.8.

• Los documentos antiguos de 0.8 "dispatch-classic" me ayudaron a comprender cómo usaban los creadores de URL y me dieron algunas pistas sobre cómo se unen las cosas que se llevaron a 0.9.

Hice una comparación de la mayoría de las principales bibliotecas de cliente HTTP disponibles

Dispatch y algunas otras bibliotecas ya no se mantienen . Los únicos serios actualmente son spray-client y Play! WS .

spray-client es un poco arcano en su sintaxis. play-ws es bastante fácil de usar:

(build.sbt)

libraryDependencies += "com.typesafe.play" %% "play-ws" % "2.4.3"

(uso básico)

val wsClient = NingWSClient()
wsClient
  .url("http://wwww.something.com")
  .get()
  .map { wsResponse =>
    // read the response
}

Un poco tarde para la fiesta aquí, pero me ha impresionado spray-client .

Tiene un buen DSL para crear solicitudes, admite ejecución sincronizada y asíncrona, así como una variedad de tipos de (des) ordenación (JSON, XML, formularios). También juega muy bien con Akka .

Dos Seis años después de responder originalmente a esta publicación, tendría una respuesta diferente.

He estado usando akka-http , una colaboración entre los equipos spray y akka. Está respaldado por Lightbend, estrechamente alineado con el entorno asíncrono akka ... es la herramienta adecuada para este trabajo.

Habiendo tenido algunas experiencias desagradables con el cliente Apache, me puse a escribir la mía propia. Se afirma ampliamente que la HttpURLConnection incorporada tiene errores. Pero esa no es mi experiencia al respecto. De hecho, lo contrario ha sido así, el cliente Apache tiene un modelo de subprocesamiento algo problemático. Desde Java6 (¿o 5?), HttpURLConnection ha proporcionado conexiones HTTP1.1 eficientes con elementos esenciales como mantener vivo integrado, y maneja el uso concurrente sin problemas.

Entonces, para compensar la API inconveniente que ofrece HttpURLConnection, me puse a escribir una nueva API en Scala, como un proyecto de código abierto. Es solo un contenedor para HttpURLConnection, pero a diferencia de HttpURLConnection, su objetivo es ser fácil de usar. A diferencia del cliente Apache, debería encajar fácilmente en un proyecto existente. A diferencia de Dispatch, debería ser fácil de aprender.

Se llama Bee Client

• Sitio web: http://www.bigbeeconsultants.co.uk/bee-client
• Documentos de API: http://www.bigbeeconsultants.co.uk/docs/bee-client/latest.html

Mis disculpas por el enchufe desvergonzado. :)

sttp es la biblioteca HTTP de Scala que todos estábamos esperando.

Tiene un DSL fluido para formar y ejecutar solicitudes (ejemplos de código de su README):

val request = sttp
  .cookie("session", "*!@#!@!$")
  .body(file) // of type java.io.File
  .put(uri"http://httpbin.org/put")
  .auth.basic("me", "1234")
  .header("Custom-Header", "Custom-Value")
  .response(asByteArray)

Admite llamadas síncronas, asíncronas y de transmisión a través de backends conectables, incluidos Akka-HTTP (anteriormente Spray) y el venerable AsyncHttpClient (Netty):

implicit val sttpHandler = AsyncHttpClientFutureHandler()
val futureFirstResponse: Future[Response[String]] = request.send()

Es compatible con scala.concurrent.Future, scalaz.concurrent.Task, monix.eval.Task, y cats.effect.IO- todos los principales Scala mónada IO bibliotecas.

Además, tiene algunos trucos adicionales bajo la manga:

• Tiene representaciones de clases de casos tanto para solicitudes como para respuestas (aunque no llega tan lejos como, por ejemplo, encabezados fuertemente tipados): https://github.com/softwaremill/sttp/blob/master/core/src/main/scala /com/softwaremill/sttp/RequestT.scala https://github.com/softwaremill/sttp/blob/master/core/src/main/scala/com/softwaremill/sttp/Response.scala

• Proporciona un interpolador de cadenas URI :

val test = "chrabąszcz majowy" val testUri: Uri = uri"http://httpbin.org/get?bug=$test"

• Admite codificadores / decodificadores para cuerpos de solicitud / respuestas, por ejemplo, JSON a través de Circe:

import com.softwaremill.sttp.circe._ val response: Either[io.circe.Error, Response] = sttp .post(uri"...") .body(requestPayload) .response(asJson[Response]) .send()

Finalmente, es mantenido por la gente confiable de softwaremill y tiene una excelente documentación .

Además de Dispatch, no hay mucho por ahí. scalaz intentó construir un cliente http funcional. Pero está desactualizado por un tiempo y no existe ninguna versión en la rama scalaz7. Además, hay un contenedor útil de ning async-http-client dentro del playframework. Allí puedes hacer llamadas como:

WS.url("http://example.com/feed").get()
WS.url("http://example.com/item").post("content")

¡Puedes usar esta API como inspiración si no usas el juego! en su proyecto y no le gusta la API de envío.

Rociar

Realmente deberías considerar usar Spray . En mi opinión, tiene una sintaxis un poco complicada, pero sigue siendo bastante útil si se pretende crear un cliente http de alto rendimiento. La principal ventaja de usar Spray es que se basa en la biblioteca de actores akka , que es extremadamente escalable y potente. Puede escalar su cliente http a varias máquinas cambiando solo los confarchivos.

Además, hace unos meses, Spray se unió a Typesafe y, según tengo entendido, se convertirá en parte de la distribución básica de akka. prueba

Play2

Otra opción es el uso de la biblioteca Play2 WS ( doc ). Por lo que sé, todavía no está separado de la distribución de Play, pero debido a su extrema simplicidad, vale la pena dedicar un tiempo a adjuntar todo el marco de Play para obtener esa parte. Hay algunos problemas al proporcionarle configuración, por lo que esto no es bueno para casos de uso y caída. Sin embargo, lo hemos usado en algunos proyectos que no están basados ​​en Play y todo estuvo bien.

ScalaJ-Http es un cliente http sincrónico muy simple

https://github.com/scalaj/scalaj-http

Lo recomendaría si necesita un cliente de Scala barebones sin ceremonias.

Sorprendido de que nadie mencionara nada aquí. Es súper simple de usar:

import com.twitter.finagle.{Http, Service}
import com.twitter.finagle.http
import com.twitter.util.{Await, Future}

object Client extends App {
  val client: Service[http.Request, http.Response] = Http.newService("www.scala-lang.org:80")
  val request = http.Request(http.Method.Get, "/")
  request.host = "www.scala-lang.org"
  val response: Future[http.Response] = client(request)
  Await.result(response.onSuccess { rep: http.Response =>
    println("GET success: " + rep)
  })
}

Consulte la guía de inicio rápido para obtener más detalles: https://twitter.github.io/finagle/guide/Quickstart.html

He usado Dispatch, Spray Client y Play WS Client Library ... Ninguno de ellos era simplemente para usar o configurar. Así que creé una biblioteca de cliente HTTP más simple que le permite realizar todas las solicitudes HTTP clásicas en simples frases.

Vea un ejemplo:

import cirrus.clients.BasicHTTP.GET

import scala.concurrent.Await
import scala.concurrent.duration._

object MinimalExample extends App {

  val html = Await.result(Cirrus(GET("https://www.google.co.uk")), 3 seconds)

  println(html)
}

... produce ...

<!doctype html><html itemscope="" itemtype="http://schema.org/WebPage" lang="en-GB">...</html>

La biblioteca se llama Cirrus y está disponible a través de Maven Central

libraryDependencies += "com.github.godis" % "cirrus_2.11" % "1.4.1"

La documentación está disponible en GitHub

https://github.com/Godis/Cirrus