The document provides an overview of the Play Framework using Scala. It discusses key features of Play including hot reloading, type safety, and predefined modules. It also covers installing Play, the MVC architecture, developing REST APIs, adding dependencies, routing, and configuration. Common commands like sbt run and sbt compile are listed. The document demonstrates creating a part-of-speech tagger using Play and Scala.

1. Play Framework
Understanding using Scala
K. Harinath
PRESENTED BY:
ClariTrics Technologies

2. Agenda
· Introduction to Scala Play
· Key Features
· Anatomy of Scala Play Application
· Architecture of Scala play
· MVC Architecture in Scala play
· Developing Rest API in Play Framework
· Adding Dependency In Play Framework
· Request URL Mapping in play
· Reading Configuration File
· Concurrent Programming in Scala
· Packing for Production – Commonly used Commands

3. Introduction to Play Framework
· Is based on a lightweight, stateless, web-friendly, non blocking architecture.
· Built on Akka, provides predictable and minimal resources consumption (CPU, memory, threads)
for highly-scalable applications.
· Lots of built in features for fast development.
· Follows MVC architecture

4. Features of Play Framework
· Strong focus on productivity. Fast turnaround.
· Hot reloading: Fix the bug and hit reload!
· Type safe all the way, even templates and route files!
· Use Scala or Java: Your choice. You can even mix them!
· Predefined module for heavy lifting. Mail Service, Authentication
· Play Provides full stack
· Websocket support
· Template Engine for views
· Testing engine

5. Installation of Play Framework
· Dependencies
· Java 1.8
· Sbt 1.1.0
· Intellji or Eclipse
· Creating New Application
· Using Play Starter Projects
· Download Play Starter
· Create a new application using SBT
· Requires giter8

6. Steps to Initialize Play
Framework
· Unzip the package and place in the desired location
· Open the package in the IntelliJ editor File->Open
· Open the terminal inside the IntelliJ editor
· Run $sbt run - Process will take more time, please wait patiently
· Application will be opened at port 9000

7. Steps – Cont 1
· Download the File
· Unzip

8. Steps – Cont 2
· Open the Folder in Intellji

9. Steps – Cont 3
· Wait till it sync
· Open the terminal

10. Steps – Cont 4
· Type sbt run
· Application will be started at localhost:9000

11. Anatomy of Play Framework

12. MVC Architecture in Play

13. Playing Around Play Framework
· Accessing the End Point
· GET http://localhost:9000 - HTML View Page
· GET http://localhost:9000/count - Count gets incremented for each page refresh or request
· GET http://localhost:9000/message - Displays Hi! Message
· Important File to Remember in Play Framework
· build.sbt – Adding third party dependency from Maven
· Conf/applicaton.conf – Contains the Play framework settings
· Conf/routes – Contains the Url Mapping
· App folder holds the controllers, views, filters etc

14. Creating Rest API using Play!

15. Hello World using Play
· Go to conf/routes
· GET /greetings controllers.HelloWorldController.index
· HelloWorldController – name of the controller class file
· Index is the function name inside the controller class file
· Create a controller called HelloWorldController.scala in app/controller
package controllers
import javax.inject._
import play.api.mvc._
/**
* This controller creates an `Action` to handle HTTP requests to the
* application's home page.
*/
@Singleton
class HelloWorldController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {
/**
Returns hello world
*/
def index = Action {
Ok("Hello World")
}
}

16. Output of Hello World

17. Adding Dependency in Play
· Using build.sbt
· // https://mvnrepository.com/artifact/org.apache.opennlp/opennlp-tools
libraryDependencies += "org.apache.opennlp" % "opennlp-tools" % "1.8.3"
· Using custom build jar
· Placing the custom build jar or jar which are not available in the Maven repository. We
should place those files inside lib in root location

18. Play Terminology
· Actions
· A Action is basically a function that handles a request and generates a result to be sent to
the client.
· Controllers
· A controller in Play is nothing more than an object that generates Action values. Controllers
are typically defined as classes to take advantage of Dependency Injection.
· Modules
· Play uses public modules to augment built-in functionality.

19. Returning Different Result Type
· val textResult = Ok("Hello World!")
· By default returns text/plain
· val xmlResult = Ok(<message>Hello World!</message>)
· Returns the result application/xml
· val htmlResult2 = Ok(<h1>Hello World!</h1>).as(HTML)
· Renders the HTML page

20. HTTP Routing
· Question ?
· Which file is responsible for URL mapping?

21. HTTP routing
· The built-in HTTP router
· The router is the component in charge of translating each incoming HTTP request to an
Action.
· An HTTP request is seen as an event by the MVC framework. This event contains two major
pieces of information:
· The request path (e.g. /clients/1542, /photos/list), including the query string
· The HTTP method (e.g. GET, POST)
· URI Pattern
· Static Path
· GET /clients/all controllers.Clients.list()
· Dynamic Parts
· GET /clients/:id controllers.Clients.show(id: Long)
· Router Feature
· What if I say you can do regex validation in route file itself !

22. Workflow of the Request from
Route file

23. Configuration File
· Play uses the Typesafe config library, but Play also provides a nice Scala wrapper called
Configuration with more advanced Scala features.
class MyController @Inject() (config: Configuration, c: ControllerComponents) extends
AbstractController(c) {
def getFoo = Action {
Ok(config.get[String]("name"))
}
}

24. Scala Concepts
· Writing Future Method
· A Future gives you a simple way to run an algorithm concurrently. A future starts running
concurrently when you create it and returns a result at some point, well, in the future.
val f = Future {
ComplexOperation // takes 100 sec approx
42
}
· Case class
· Case classes are like regular classes with a few key differences which we will go over. Case
classes are good for modeling immutable data
case class Book(isbn: String)
val frankenstein = Book("978-0486282114")

25. Creating Part of Speech Tagger
def convertPos(data:String) = Future {
var result:String = ""
if(data.isEmpty)
Future.successful(BadRequest("Data is empty"))
try {
// converting option[x] to x
// val sentence = data.get
// tokenize the sentence
val projectPath = Play.application().path();
var tokenModelIn = new FileInputStream(projectPath+"/conf/resource/en-token.bin")
val tokenModel = new TokenizerModel(tokenModelIn)
val tokenizer = new TokenizerME(tokenModel)
val tokens = tokenizer.tokenize(data)
// Parts-Of-Speech Tagging
// reading parts-of-speech model to a stream
var posModelIn = new FileInputStream(projectPath+ "/conf/resource/en-pos-maxent.bin")
// loading the parts-of-speech model from stream
val posModel = new POSModel(posModelIn)
// initializing the parts-of-speech tagger with model
val posTagger = new POSTaggerME(posModel)
// Tagger tagging the tokens
val tags = posTagger.tag(tokens)
// Getting the probabilities of the tags given to the tokens
val probs = posTagger.probs
// Iterates the token, tag and probability score
// Flattening to list makes into string
result++= (0 until tokens.length).map(i => tokens(i) + "t:t" + tags(i) + "t:t" + probs(i) + "n").flatten.toList
} catch {
case e: IOException =>
// Model loading failed, handle the error
e.printStackTrace()
}
result.toString
}

26. Commonly used Command
· Sbt run
· Sbt compile
· Sbt update
· Sbt dist

27. References
· Scala Programming Language (Wikipedia Article)
· Scala official site
· Typesafe
· Programming in Scala Book on Amazon
· Functional Programming Principles in Scala on Coursera
· Principles of Reactive Programming on Coursera
· Play Framework Official Website
· Play Framework (Wikipedia Article)
· Typesafe Activator

28. Questions?
harinath@claritrics.com
CONTACT: