Play framework training by Neelkanth Sachdeva @ Scala traits event , New Delhi by Knoldus Software LLP

3,867 views

Published on

Play framework training by Neelkanth Sachdeva @ Scala traits event , New Delhi by Knoldus Software LLP

Published in: Technology, Education
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,867
On SlideShare
0
From Embeds
0
Number of Embeds
2,305
Actions
Shares
0
Downloads
62
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Play framework training by Neelkanth Sachdeva @ Scala traits event , New Delhi by Knoldus Software LLP

  1. 1. Knoldus Software LLP Knoldus Software LLP New Delhi , India www.knoldus.com Neelkanth Sachdeva @NeelSachdeva neelkanthsachdeva.wordpress.com Kick start to
  2. 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/
  3. 3. Knoldus Software LLP Introduction to
  4. 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. 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. 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. 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. 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. 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. 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. 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
  12. 12. Knoldus Software LLP
  13. 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. 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. 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. 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. 17. Knoldus Software LLP ● Because Templates are compiled, so you will see any errors right in your browser
  18. 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. 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. 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. 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. 22. Compile time checking by Play - HTTP routes file - Templates - Javascript files - Coffeescript files - LESS style sheets
  23. 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. 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. 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. 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. 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. 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. 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. 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. 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. 32. 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)
  33. 33. 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") } } }
  34. 34. Let us make a POST request containing XML data
  35. 35. 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).
  36. 36. Defining The Route : POST /greet controllers.Application.greet Defining The Controller : package controllers import play.api.mvc.Controller import play.api.mvc.Action object Application extends Controller { def greet = Action { request => request.body.asJson.map { json => (json "name").asOpt[String].map { name => Ok("Hello " + name + " ") }.getOrElse { BadRequest("Missing parameter [name]") } }.getOrElse { BadRequest("Expecting Json data") } } }
  37. 37. Lets make a POST request containing JSON data
  38. 38. Knoldus Software LLP Lets then
  39. 39. 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
  40. 40. 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
  41. 41. 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.
  42. 42. Knoldus Software LLP Creating a new project
  43. 43. Knoldus Software LLP ● Clone MyOffice app from here as git clone git@github.com:knoldus/ScalaTraits-August2013-Play.git
  44. 44. Knoldus Software LLP Importing the project in to eclipse IDE
  45. 45. Knoldus Software LLP Running the project
  46. 46. Knoldus Software LLP The Project Structure
  47. 47. 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.
  48. 48. 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.
  49. 49. 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)
  50. 50. 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 }
  51. 51. 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.
  52. 52. 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
  53. 53. 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) {} }
  54. 54. 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.
  55. 55. 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.
  56. 56. Knoldus Software LLP @(employees: List[Employee], employeeForm: Form[String]) @import helper._ @main("My Office") { <h1>Presently @employees.size employee(s)</h1> <ul> @employees.map { employee => <li> @employee.name @form(routes.MyOfficeController.deleteEmployee(employee.id)) { <input type="submit" value="Remove Employee"> } </li> } </ul> <h2>Add a new Employee</h2> @form(routes.MyOfficeController.newEmployee) { @inputText(employeeForm("name")) <input type="submit" value="Add Employee"> } }
  57. 57. 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.
  58. 58. Knoldus Software LLP
  59. 59. 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) }) }
  60. 60. 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.
  61. 61. 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;
  62. 62. Knoldus Software LLP Now if you refresh your browser, Play will warn you that your database needs evolution:
  63. 63. 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.
  64. 64. 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) }
  65. 65. 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() } }
  66. 66. Knoldus Software LLP That's it
  67. 67. Knoldus Software LLP Let us use the Application “MyOffice”
  68. 68. Knoldus Software LLP Lets deploy the App to
  69. 69. 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.
  70. 70. Knoldus Software LLP Procfile content : web: target/start -Dhttp.port=$PORT -DapplyEvolutions.default=true
  71. 71. 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 .
  72. 72. 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//
  73. 73. 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.
  74. 74. Knoldus Software LLP

×