In the last days I’ve been playing with http4s which is defined as a minimal, idiomatic Scala interface for HTTP.

It’s a powerful library, type safe, composable and asynchronous. And it supports different servers like Blaze, Jetty and Tomcat.

Although the project remains a lot of work it’s always good to give it a try.

CREATING THE FIRST HTTP SERVICE

I started creating a basic service that returns a simple string when accessing the root level (localhost:8080/). This is how it looks:

object HomeService { def apply(): HttpService = service private val service = HttpService { case GET -> Root => Ok("Http4s API") } }

And here is the main application that runs the Blaze server:

object Api extends App { BlazeBuilder.bindHttp(8080) .mountService(HomeService(), "/") .run .awaitShutdown() }

Fair enough to get a server running and serving a GET resource. Until here we have the “hello world” example of an HTTP service. After this we can create more services and add them to the server by invoking the mountService function of the server builder.

What I did was to create two similar services for Products and Users serving just mocking data. However the main difference is that the ProductService serves Json data using Play Json and the UserService exposes Json data using Circe.

PRODUCT SERVICE

This is the code for one of the GET resources for the ProductService:

case GET -> Root => val products = List(Product(1, "Book"), Product(2, "Calc"), Product(3, "Guitar")) Ok(Json.toJson(products))

It’s very handy. However to get this code working you need some implicit values in the scope:

The Writer for the Play Json library.

The EntityEncoder[T] for http4s.

To accomplish this requirements I created the following object that is imported in the ProductService:

object PlayJsonImplicits { implicit val playJsonEncoder: EntityEncoder[JsValue] = EntityEncoder .stringEncoder(Charset.`UTF-8`) .contramap { json: JsValue => json.toString() } .withContentType(`Content-Type`(MediaType.`application/json`, Charset.`UTF-8`)) implicit val productJsonFormat = Json.format[Product] }

USER SERVICE

This is the code for one of the GET resources of the UserService:

case GET -> Root / id => Ok(User(id.toLong, s"User$id", s"user$id@mail.com").asJson)

And here it happens something similar to the service above. In this case we need to import the Circe implicit values and to provide an EntityEncoder[T]. This is how it looks:

import io.circe.generic.auto._ import io.circe.syntax._

object CirceImplicits { implicit val circeJsonEncoder: EntityEncoder[CirceJson] = EntityEncoder .stringEncoder(Charset.`UTF-8`) .contramap { json: CirceJson => json.noSpaces } .withContentType(`Content-Type`(MediaType.`application/json`, Charset.`UTF-8`)) }

Until here we have a few services serving Json data but the most attracting feature of this library is the streaming one. So let’s move on some examples.

STREAMING DATA

Http4s was built on top of Scalaz Streams and every Request is transformed into an asynchronous Scalaz Task[Response]. This means that you can use any function that returns an async Task as a Http Response using the helpers provided by http4s.

Here we have an example extracted from the StreamingService:

private val service = HttpService { case GET -> Root => val streamingData = Process.emit(s"Starting stream intervals



") ++ dataStream(10) Ok(streamingData).chunked } private def dataStream(n: Int): Process[Task, String] = { implicit def defaultScheduler = DefaultTimeoutScheduler val interval = 100.millis time.awakeEvery(interval) .map(_ => s"Current system time: ${System.currentTimeMillis()} ms

") .take(n) }

To send the chunked response we need to add the Transfer Encoding header as below. What I did was to create an implicit class with a “chunked” function to make thinks easier.

response.putHeaders(`Transfer-Encoding`(TransferCoding.chunked))

And that’s it! Find out more and what is possible to do with Scalaz Streams by taking a look at the examples.

Another cool feature of this library is the Web Sockets support, but I’m not covering this topic now. However you’ll find a very basic example of WS connection in the sample project linked below. And maybe you want to take a look at this demo too.

TEST COVERAGE

As always this development stage is for me the most important. That’s why all the services are fully tested with a test coverage close to ~100% (actually Coveralls has some bugs and it’s showing only 92% but take a look at the coverage report! If you run “sbt clean coverage test” the coverage report shows 97.78%).

This is how it looks one of the unit tests for the ProductService:

"Get the list of products" in { val request = new Request() val response = service.run(request).run response.status should be (Status.Ok) val expected = """ [{"id":1,"name":"Book"},{"id":2,"name":"Guitar"}] """.trim response.body.asString should be (expected) }

We are creating a Request and running the ProductService to get the response. Then we have assertions for the Status and the Body.

SAMPLE PROJECT

Check out the complete project on Github!.

Important Note: Only runs under Java 8.

Find out more examples in the official http4s ExampleService.

CONCLUSION

At this moment the documentation it’s a bit poor but I hope to find a better one in the future and many other improvements. Nevertheless I know the guys are working really hard on this powerful library.

Well, this was just a quick research, you are always invited to go deeper and deeper!

Until next post!

Gabriel.