Scala developers-Advanced routing for Scala

Javascript Routing

To manage routing from Javascript that is running client-side back to your application, the play router can produce Javascript code. Refactoring your application is made more accessible by the Javascript router. Your Javascript is immediately updated to reflect the new structure if you modify the URL or parameter name structure.

Generating a Javascript router

The generation of Play's Javascript router is the initial step in using it. To reduce the amount of the Javascript code, the router will only expose the routes you expressly designate.

A Javascript router can be created in two different methods. One is to use template directives to incorporate the router within the HTML page. The alternative is to generate Javascript assets through a process that may be downloaded, cached and shared between pages.

Embedded router

The @javascriptRouter directive inside a Scala template can create an embedded router. Usually, this is carried out within the main decorative template.

@()(implicit req: play.api.mvc.RequestHeader)

@helper.javascriptRouter("jsRoutes")(
    routes.javascript.Users.list,
    routes.javascript.Users.get
)

The first option specifies the name of the global variable in which the router will be stored (routes.javascript.Users.list, routes.javascript.Users.get). The second option is the list of Javascript routes that should be added to this router. From the above example, your template must have an implicit RequestHeader in scope to use this function.

Router resource

A router resource may be generated by developing an action that uses the router generator. The syntax is the same as when the router is embedded in a template:

import javax.inject.Inject
import play.api.http.MimeTypes
import play.api.mvc._
import play.api.routing._

def javascriptRoutes = Action { implicit request =>
  Ok(
    JavaScriptReverseRouter("jsRoutes")(
      routes.javascript.Users.list,
      routes.javascript.Users.get
    )
  ).as(MimeTypes.JAVASCRIPT)
}

Using the router

Making a call is easy, for instance, using jQuery:

$.ajax(jsRoutes.controllers.Users.get(someId))
  .done( /*...*/ )
  .fail( /*...*/ );

Other attributes made available by the router include the type and the url (the HTTP method). For instance, the ajax function call made in the example above can also be made as follows:

var r = jsRoutes.controllers.Users.get(someId);
$.ajax({url: r.url, type: r.type, success: /*...*/, error: /*...*/ });

When other properties, such as success, error, context, etc., need to be set, the strategy above is necessary.

The entire url string is returned via the methods (not properties) absoluteURL and webSocketURL. Creating a Websocket connection looks like this:

var r = jsRoutes.controllers.Users.list();
var ws = new WebSocket(r.webSocketURL());
ws.onmessage = function(msg) {
        /*...*/
};

Custom Routing

PathBindable

PathBindable enables the binding of business objects from the URL path; as a result, we may construct routes like /user/1 to invoke the following action:

def user(user: User) = Action {
  Ok(user.name)
}

An easy illustration of the binder using the :id path parameter:

implicit def pathBinder(implicit intBinder: PathBindable[Int]) = new PathBindable[User] {
  override def bind(key: String, value: String): Either[String, User] = {
    for {
      id   <- intBinder.bind(key, value).right
      user <- User.findById(id).toRight("User not found").right
    } yield user
  }
  override def unbind(key: String, user: User): String = {
    user.id.toString
  }
}

In this example, the findById method is used to retrieve the User instance; however, in the real world, findById methods should be lightweight and avoid using database access, for example, since they are executed on the server's IO thread and must be completely non-blocking.

As a result, you might, for instance, utilize simple object identifiers as path bindable and use action composition to get the actual values.

QueryStringBindable

For query string arguments, a similar method is employed; a route like /age can be built to invoke an operation like

def age(age: AgeRange) = Action {
  Ok(age.from.toString)
}

An easy case of the:from and:to query string parameters being bound by the binder:

implicit def queryStringBindable(implicit intBinder: QueryStringBindable[Int]) = new QueryStringBindable[AgeRange] {
  override def bind(key: String, params: Map[String, Seq[String]]): Option[Either[String, AgeRange]] = {
    for {
      from <- intBinder.bind("from", params)
      to   <- intBinder.bind("to", params)
    } yield {
      (from, to) match {
        case (Right(from), Right(to)) => Right(AgeRange(from, to))
        case _                        => Left("Unable to bind an AgeRange")
      }
    }
  }
  override def unbind(key: String, ageRange: AgeRange): String = {
    intBinder.unbind("from", ageRange.from) + "&" + intBinder.unbind("to", ageRange.to)
  }
}

All the binders that Play offers automatically apply form URL encoding in their unbind methods, safely encoding all special characters.

Frequently Asked Questions

What is Scala?

Scala is an open-source, general purpose, multiple paradigm programming language. It supports both functional and object-oriented programming principles.

What exactly is Scala Framework?

Ruby software includes the Scala domain-specific language and the web application library. Instead of Ruby on Rails, Merb, Nitro, and Camping, it uses a Ruby web application framework called Camping. It depends on the Rack web server interface. As a mark of respect, it carries Frank Scala's name.

What do you mean by Rails with Scala?

In contrast to Rails, a framework for creating model-driven online applications, Scala is a server-side HTTP library. If you think of HTTP requests and responses, Scala is the finest tool. If you need complete integration with the least amount of boilerplate possible, Rails is the way to go.

What exactly does a Scala developer do?

A Scala developer is responsible for designing,  developing, and managing scala-based web applications. They should be familiar with the concepts of Scala knowledge, including but not limited to functional and object-oriented programming paradigms.

Does Scala outperform Java? 

According to the study, Scala is quicker than Java and Go when typical developers write code without much thought to optimization. The study took advantage of each language's standard, idiomatic data structures.

Conclusion

This article taught us advanced routing for scala. I hope you would have gained a better understanding of these topics now!

If you want to learn more about CherryPy topics, follow the link given below:

• Working with XML
• Accessing an SQL Database
• Integration with Akka
• Application Settings
   

Refer to our guided paths on Coding Ninjas Studio to learn about Data Structure and Algorithms, Competitive Programming, JavaScript, etc. Enroll in our courses and refer to our mock test available. Have a look at the interview experiences and interview bundle for placement preparations.

Please upvote our blog to help other ninjas grow.

Happy Learning!