This document provides an introduction and overview of the Play web application framework. It discusses key components of Play like Actions, Controllers, Results, routing, templates, and forms. It also covers how to develop a basic application using Play including setting up a new project, defining routes and controllers, rendering templates, and submitting forms. Finally, it demonstrates persisting application data in a database.
1. Knoldus Software LLP
Knoldus Software LLP
New Delhi , India
www.knoldus.com
Neelkanth Sachdeva
@NeelSachdeva
neelkanthsachdeva.wordpress.com
Kick start to
2. Knoldus Software LLP
I am
Software Consultant
@ Knoldus Software LLP , New Delhi
( The only Typesafe partner in Asia )
http://www.knoldus.com/
Co-Founder
@ My Cell Was Stolen
http://www.mycellwasstolen.com/
4. Knoldus Software LLP
Agenda
Introduction
● Overview
● Features of Play
● Components of Play
● Action , Controller ,
Result
● Routes
● The template engine
● HTTP Form
Other concepts
● Web Services
● Working with XML
● Working with JSON
Development
● Developing a application
using Play
Deployment
● Deploying the Play
application to Heroku
5. Knoldus Software LLP
Overview
Play framework is :
➢ Created by Guillaume Bort, while working at Zenexity.
➢ An open source web application framework.
➢ Lightweight, stateless, web-friendly architecture.
➢ Written in Scala and Java.
➢ Support for the Scala programming language has been
available since version 1.1 of the framework.
6. Knoldus Software LLP
Features of Play!
➢ Stateless architecture
➢ Less configuration: Download, unpack and
develop.
➢ Faster Testing
➢ More elegant API
➢ Modular architecture
➢ Asynchronous I/O
7. Knoldus Software LLP
Stateless Architecture-The base of Play
Each request as an independent transaction
that is unrelated to any previous request so that
the communication consists of independent
pairs of requests and responses.
8. Knoldus Software LLP
Basic Play ! components
➢ JBoss Netty for the web server.
➢ Scala for the template engine.
➢ Built in hot-reloading
➢ sbt for dependency management
9. Knoldus Software LLP
Action, Controller & Result
Action :-
Most of the requests received by a Play application are
handled by an Action.
A play.api.mvc.Action is basically a
(play.api.mvc.Request => play.api.mvc.Result)
function that handles a request and generates a
result to be sent to the client.
val hello = Action { implicit request =>
Ok("Request Data [" + request + "]")
}
10. Knoldus Software LLP
● Controllers :-
Controllers are action generators.
A singleton object that generates Action values.
The simplest use case for defining an action
generator is a method with no parameters that
returns an Action value :
import play.api.mvc._
object Application extends Controller {
def index = Action {
Ok("Controller Example")
}
}
11. Knoldus Software LLP
val ok = Ok("Hello world!")
val notFound = NotFound
val pageNotFound = NotFound(<h1>Page not found</h1>)
val badRequest =
BadRequest(views.html.form(formWithErrors))
val oops = InternalServerError("Oops")
val anyStatus = Status(488)("Strange response type")
Redirect(“/url”)
Results
13. Knoldus Software LLP
package controllers
import play.api._
import play.api.mvc._
object Application extends Controller {
def index = Action {
//Do something
Ok
}
}
Controller ( Action Generator )
index Action
Result
14. Knoldus Software LLP
HTTP routing :
An HTTP request is treated as an event by the
MVC framework. This event contains two
major pieces of information:
● The request path (such as /local/employees ),
including the query string.
● The HTTP methods (GET, POST, …).
Routes
15. Knoldus Software LLP
The conf/routes file
# Home page
GET / controllers.Application.index
GET - Request Type ( GET , POST , ... ).
/ - URL pattern.
Application - The controller object.
Index - Method (Action) which is being called.
16. Knoldus Software LLP
The template engine
➢ Based on Scala
➢ Compact, expressive, and fluid
➢ Easy to learn
➢ Play Scala template is a simple text file, that contains
small blocks of Scala code. They can generate any text-
based format, such as HTML, XML or CSV.
➢ Compiled as standard Scala functions.
17. Knoldus Software LLP
● Because Templates are compiled, so you will see any
errors right in your browser
18. @main
● views/main.scala.html template act as a
main layout template. e.g This is our
Main template.
@(title: String)(content: Html)
<!DOCTYPE html>
<html>
<head>
<title>@title</title>
</head>
<body>
<section class="content">@content</section>
</body>
</html>
19. ● As you can see, this template takes two
parameters: a title and an HTML content block.
Now we can use it from any other template e.g
views/Application/index.scala.html template:
@main(title = "Home") {
<h1>Home page</h1>
}
Note: We sometimes use named parameters(like @main(title =
"Home"), sometimes not like@main("Home"). It is as you want,
choose whatever is clearer in a specific context.
20. Syntax : the magic ‘@’ character
Every time this character is encountered, it indicates the
begining of a Scala statement.
@employee.name // Scala statement starts here
Template parameters
A template is simply a function, so it needs parameters,
which must be declared on the first line of the template
file.
@(employees: List[Employee], employeeForm: Form[String])
21. Iterating : You can use the for keyword in order
to iterate.
<ul>
@for(c <- customers) {
<li>@c.getName() ($@c.getCity())</li>
}
</ul>
If-blocks : Simply use Scala’s standard if
statement:
@if(customers.isEmpty()) {
<h1>Nothing to display</h1>
} else {
<h1>@customers.size() customers!</h1>
}
22. Compile time checking by Play
- HTTP routes file
- Templates
- Javascript files
- Coffeescript files
- LESS style sheets
23. HTTP Form
The play.api.data package contains several
helpers to handle HTTP form data submission
and validation. The easiest way to handle a form
submission is to define a play.api.data.Form
structure:
24. Lets understand it by a defining simple form
object FormExampleController extends Controller {
val loginForm = Form(
tuple(
"email" -> nonEmptyText,
"password" -> nonEmptyText))
}
This form can generate a (String, String) result
value from Map[String, String] data:
25. The corresponding template
@(loginForm :Form[(String, String)],message:String)
@import helper._
@main(message){
@helper.form(action = routes.FormExampleController.authenticateUser) {
<fieldset>
<legend>@message</legend>
@inputText(
loginForm("email"), '_label -> "Email ",
'_help -> "Enter a valid email address."
)
@inputPassword(
loginForm("password"),
'_label -> "Password",
'_help -> "A password must be at least 6 characters."
)
</fieldset>
<input type="submit" value="Log in ">
}
}
26. Putting the validation
● We can apply the validation at the time of
defining the form controls like :
val loginForm = Form(
tuple(
"email" -> email,
"password" -> nonEmptyText(minLength = 6)))
●
email means : The textbox would accept an valid Email.
●
nonEmptyText(minLength = 6) means : The textbox would accept atleast 6
characters
27. Constructing complex objects
You can use complex form mapping as well.
Here is the simple example :
case class User(name: String, age: Int)
val userForm = Form(
mapping(
"name" -> text,
"age" -> number)(User.apply)(User.unapply))
28. Calling WebServices
● Sometimes there becomes a need to call other
HTTP services from within a Play application.
● This is supported in Play via play.api.libs.ws.WS
library, which provides a way to make asynchronous
HTTP calls.
● It returns a Promise[play.api.libs.ws.Response].
29. Making an HTTP call
● GET request :
val returnedValue : Promise[ws.Response] = WS.url("http://mysite.com").get()
● POST request :
WS.url("http://mysite.com").post(Map("key" -> Seq("value")))
30. Example
● Lets make a WS GET request on
ScalaJobz.com API.
● Result :
This call would return the JSON of jobs from
scalajobz.com.
31. ● Route definition:
GET /jobs controllers.Application.jobs
● Controller :
/**
* Calling web services
*/
def jobs = Action {
WS.url("http://www.scalajobz.com/getAllJobs").get().map
{
response => println(response.json)
}
Ok("Jobs Fetched")
}
32.
33. Working with XML
●
An XML request is an HTTP request using a valid.An XML request is an HTTP request using a valid.
XML payload as the request body.XML payload as the request body.
●
It must specify theIt must specify the text/xmltext/xml MIME type in itsMIME type in its
Content-TypeContent-Type header.header.
●
By default anBy default an ActionAction uses a any content bodyuses a any content body
parser, which lets you retrieve the body as XMLparser, which lets you retrieve the body as XML
(as a NodeSeq)(as a NodeSeq)
34. Defining The Route :
POST /sayHello controllers.Application.sayHello
Defining The Controller :
package controllers
import play.api.mvc.Action
import play.api.mvc.Controller
object Application extends Controller {
def sayHello = Action { request =>
request.body.asXml.map { xml =>
(xml "name" headOption).map(_.text).map { name =>
Ok("Hello " + name + " ")
}.getOrElse {
BadRequest("Missing parameter [name]")
}
}.getOrElse {
BadRequest("Expecting Xml data")
}
}
}
35. Let us make a POST request containing XML data
36. Working with JSON
1. A JSON request is an HTTP request using a valid JSON1. A JSON request is an HTTP request using a valid JSON
payload as request body.payload as request body.
2. It must specify the text/json or application/json mime type2. It must specify the text/json or application/json mime type
in its Content-Type header.in its Content-Type header.
3. By default an Action uses an any content body parser,3. By default an Action uses an any content body parser,
which lets you retrieve the body as JSON.which lets you retrieve the body as JSON.
(as a JsValue).(as a JsValue).
40. Knoldus Software LLP
Prerequisites
1. Download the Scala SDK from here.
http://scala-ide.org/download/sdk.html
2. A basic knowledge of the Eclipse user interface
41. Knoldus Software LLP
Setting up Play 2.1
1. Download Play framework 2.1.3 from
http://www.playframework.org.
2. Unzip it in your preferred location. Let's say
/path/to/play for the purpose of this document.
3. Add the Play folder to your system PATH
export PATH=$PATH:/path/to/play
42. Knoldus Software LLP
Creating a Play 2.1.3 application
In your development folder, ask Play to create
a new web application, as a simple Scala
application.
48. Knoldus Software LLP
The project “MyOffice” mainly contains :
● app / : Contains the application’s core, split
between models, controllers and views
directories.
● Conf / : Contains the configuration files.
Especially the main application.conf file,the
routes definition files. routes defines the
routes of the UI calls.
49. Knoldus Software LLP
● project :: Contains the build scripts.
● public / :: Contains all the publicly available
resources, which includes JavaScript,
stylesheets and images directories.
● test / :: Contains all the application tests.
50. Knoldus Software LLP
Edit the conf/routes file:
# Home page
GET / controllers.Application.index
# MyOffice
GET /employees controllers.MyOfficeController.employees
POST /newEmployee controllers.MyOfficeController.newEmployee
POST /employee/:id/deleteEmployee
controllers.MyOfficeController.deleteEmployee(id: Long)
51. Knoldus Software LLP
Add the MyOfficeController.scala object under controllers
& define the methods those will perform the action.
package controllers
import play.api.mvc._
object MyOfficeController extends Controller {
/**
* Total Employees In Office
*/
def employees = TODO
/**
* Add A New Employee
*/
def newEmployee = TODO
/**
* Remove An Employee
*/
def deleteEmployee(id: Long) = TODO
}
52. Knoldus Software LLP
● As you see we use TODO to define our action
implementations. Because we haven't write the action
implementations yet, we can use the built-in TODO action
that will return a 501 Not Implemented HTTP response.
Now lets hit the http://localhost:9000/employees & see what
we find.
53. Knoldus Software LLP
● Lets define the models in our MyOffice
application that will perform the business logic.
Preparing the Employee model
Before continuing the implementation we need to define how the
Employee looks like in our application.
Create a case class for it in the app/models/Employee.scala file.e.
case class Employee(id: Long, name : String)
Each Employee is having an :
● Id - That uniquely identifies the Employee
● name - Name of the Employee
54. Knoldus Software LLP
The Employee model
package models
case class Employee(id: Long, name: String)
object Employee {
/**
* All Employees In Office
*/
def allEmployees(): List[Employee] = Nil
/**
* Adding A New Employee
*/
def newEmployee(nameOfEmployee: String) {}
/**
* Delete Employee
* @param id : id Of The Employee To Be Deleted
*/
def delete(id: Long) {}
}
55. Knoldus Software LLP
Now we have our :
- Controller MyOfficeController.scala
- Model Employee.scala
Lets write Application template employee.scala.html.
The employee form :
Form object encapsulates an HTML form definition, including
validation constraints. Let’s create a very simple form in the
Application controller: we only need a form with a single
name field. The form will also check that the name provided
by the user is not empty.
56. Knoldus Software LLP
The employee form in MyOfficeController.scala
val employeeForm = Form(
"name" -> nonEmptyText)
The employee form in MyOfficeController.scalaThe employee form in MyOfficeController.scala
The type of employeeForm is the Form[String] since it
is a form generating a simple String. You also need to
Import some play.api.data classes.
58. Knoldus Software LLP
Rendering the employees.scala.html page
Assign the work to the controller method
employees.
/**
* Total Employees In Office
*/
def employees = Action {
Ok(views.html.employee(Employee.allEmployees(), employeeForm))
}
● Now hit the http://localhost:9000/employees and
see what happens.
60. Knoldus Software LLP
Form Submission
●
For now, if we submit the employee creation form, we still get theFor now, if we submit the employee creation form, we still get the
TODO page. Let’s write the implementation of theTODO page. Let’s write the implementation of the newEmployeenewEmployee
action :action :
def newEmployee = Action { implicit request =>
employeeForm.bindFromRequest.fold(
errors =>
BadRequest(views.html.employee(Employee.allEmployees(),
employeeForm)),
name => {
Employee.newEmployee(name)
Redirect(routes.MyOfficeController.employees)
})
}
61. Knoldus Software LLP
Persist the employees in a database
● It’s now time to persist the employees in a database to
make the application useful. Let’s start by enabling a
database in our application. In the conf/application.conf
file, add:
db.default.driver=org.h2.Driver
db.default.url="jdbc:h2:mem:play"
For now we will use a simple in memory database using H2.
No need to restart the server, refreshing the browser is
enough to set up the database.
62. Knoldus Software LLP
● We will use Anorm in this tutorial to query the database.
First we need to define the database schema. Let’s use Play
evolutions for that, so create a first evolution script in
conf/evolutions/default/1.sql:
# Employees schema
# --- !Ups
CREATE SEQUENCE employee_id_seq;
CREATE TABLE employee (
id integer NOT NULL DEFAULT nextval('employee_id_seq'),
name varchar(255)
);
# --- !Downs
DROP TABLE employee;
DROP SEQUENCE employee_id_seq;
63. Knoldus Software LLP
Now if you refresh your browser, Play will warn you that your
database needs evolution:
64. Knoldus Software LLP
● It’s now time to implement the SQL queries in the Employee companion
object, starting with the allEmployees() operation. Using Anorm we can
define a parser that will transform a JDBC ResultSet row to a Employee value:
import anorm._
import anorm.SqlParser._
val employee = {
get[Long]("id") ~
get[String]("name") map {
case id ~ name => Employee(id, name)
}
}
Here, employee is a parser that, given a JDBC ResultSet rowHere, employee is a parser that, given a JDBC ResultSet row
with at least an id and a name column, is able to create awith at least an id and a name column, is able to create a
Employee value.Employee value.
65. Knoldus Software LLP
Let us write the implementation of our methods in Employee model.
/**
* Add A New Employee
*/
def newEmployee = Action { implicit request =>
employeeForm.bindFromRequest.fold(
errors =>
BadRequest(views.html.employee(Employee.allEmployees(),
employeeForm)),
name => {
Employee.newEmployee(name)
Redirect(routes.MyOfficeController.employees)
})
}
/**
* Remove An Employee
*/
def deleteEmployee(id: Long) = Action {
Employee.delete(id)
Redirect(routes.MyOfficeController.employees)
}
66. Knoldus Software LLP
The model methods
/**
* All Employees In Office
*/
def allEmployees(): List[Employee] = DB.withConnection { implicit c =>
SQL("select * from employee").as(employee *)
}
/**
* Adding A New Employee
*/
def newEmployee(nameOfEmployee: String) {
DB.withConnection { implicit c =>
SQL("insert into employee (name) values ({name})").on(
'name -> nameOfEmployee).executeUpdate()
}
}
/**
* Delete Employee
* @param id : id Of The Employee To Be Deleted
*/
def delete(id: Long) {
DB.withConnection { implicit c =>
SQL("delete from employee where id = {id}").on(
'id -> id).executeUpdate()
}
}
70. Knoldus Software LLP
Heroku needs a file named ‘Procfile‘ for each
application to be deployed on it.
What is Procfile ?
Procfile is a mechanism for declaring what
commands are run when your web or worker
dynos are run on the Heroku platform.
72. Knoldus Software LLP
Lets Deploy our application
1. Create a file Procfile and put it in the root of
your project directory.
2. Initiate the git session for your project and
add files to git as
git init
git add .
73. Knoldus Software LLP
3. Commit the changes for the project to git as
git commit -m init
4. On the command line create a new application
using the “cedar” stack:
heroku create -s cedar
5. Add the git remote :
git remote add heroku //TheCloneUrlOnTheHerokuApp//
74. Knoldus Software LLP
6. Application is ready to be deployed to the cloud. push
the project files to heroku as:
git push heroku master
Go to your heroku account -> MyApps and you’ll
find a new application that you had just created.
Launch the URL and have a look to your running
application on heroku. You can also rename your
application.