Play!ng with scala

ng with
2.0

Siarzh Miadzvedzeu @siarzh

is

“a web framework for a new era”

&

“designed by web developers
for web developers”
Guillaume Bort, creator

2.0 is

• full stack web framework for JVM
• high-productive
• asynch & reactive
• stateless
• HTTP-centric
• typesafe
• scalable
• open source
• part of Typesafe Stack 2.0

2.0 is fun and high-productive

• fast turnaround: change you code and hit reload! :)
• browser error reporting
• db evolutions
• modular and extensible via plugins
• minimal bootstrap
• integrated test framework
• easy cloud deployment (e.g. Heroku)

2.0 is asynch & reactive

• WebSockets
• Comet
• HTTP 1.1 chuncked responses
• composable streams handling
• based on event-driven, non-blocking Iteratee I/O

2.0 is HTTP-centric

• based on HTTP and stateless
• doesn't fight HTTP or browser
• clean & easy URL design (via routes)
• designed to work with HTML5

“When a web framework starts an architecture fight
with the web, the framework loses.”

2.0 is typesafe where it matters

}
• templates
• routes
• configs
• javascript (via Goggle Closure)
all are compiled
• LESS stylesheets
• CoffeeScript

+ browser error reporting

2.0 getting started

1. download Play 2.0 binary package

2. add play to your PATH:
export PATH=$PATH:/path/to/play20

3. create new project:
$ play new myFirstApp

4. run the project:
$ cd myFirstApp
$ play run

2.0 config
single conf/application.conf:
# This is the main configuration file for the application.

# The application languages
# ~~~~~
application.langs="en"

# Database configuration
# ~~~~~
# You can declare as many datasources as you want.
# By convention, the default datasource is named `default`
#
db.default.driver=org.h2.Driver
db.default.url="jdbc:h2:mem:play"
# db.default.user=sa
# db.default.password=

# Evolutions
# ~~~~~
# You can disable evolutions if needed
# evolutionplugin=disabled
...

2.0 IDE support
Eclipse: $ eclipsify

IntelliJ IDEA: $ idea

Netbeans: add to plugins.sbt:
resolvers += {
"remeniuk repo" at "http://remeniuk.github.com/maven"
}

libraryDependencies += {
"org.netbeans" %% "sbt-netbeans-plugin" % "0.1.4"
}

$ play netbeans

2.0 and SBT
Build.scala plugins.sbt
import sbt._ addSbtPlugin("play" % "sbt-plugin" % "2.0")
import Keys._
import PlayProject._

object ApplicationBuild extends Build {

val appName = "Your application"
val appVersion = "1.0"

val appDependencies = Seq(
// Add your project dependencies here,
)

val main = PlayProject(
appName, appVersion, appDependencies,
mainLang = SCALA
).settings(
// Add your own project settings here
)

}

2.0 routes
# Home page
GET / controllers.Application.homePage()
GET /home controllers.Application.show(page = "home")

# Display a client.
GET /clients/all controllers.Clients.list()
GET /clients/:id controllers.Clients.show(id: Long)

# Pagination links, like /clients?page=3
GET /clients controllers.Clients.list(page: Int ?= 1)

# With regex
GET /orders/$id<[0-9]+> controllers.Orders.show(id: Long)

# 'name' is all the rest part of the url including '/' symbols
GET /files/*name controllers.Application.download(name)

2.0 reversed routing

# Hello action
GET /helloBob controllers.Application.helloBob
GET /hello/:name controllers.Application.hello(name)

// Redirect to /hello/Bob
def helloBob = Action {
Redirect( routes.Application.hello("Bob") )
}

2.0 actions
action: (play.api.mvc.Request => play.api.mvc.Result)

Action(parse.text) { request =>
Ok("<h1>Got: " + request.body + "</h1>").as(HTML).withSession(
session + ("saidHello" -> "yes")
).withHeaders(
CACHE_CONTROL -> "max-age=3600",
ETAG -> "xx"
).withCookies(
Cookie("theme", "blue")
)
}

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")

2.0 controllers

package controllers

import play.api.mvc._

object Application extends Controller {

def index = Action {
Ok("It works!")
}

def hello(name: String) = Action {
Ok("Hello " + name)
}

def goodbye(name: String) = TODO

}

2.0 templates
…are just functions ;)
views/main.scala.html: @(title: String)(content: Html)
<!DOCTYPE html>
<html>
<head>
<title>@title</title>
</head>
<body>
<section class="content">@content</section>
</body>
</html>

views/hello.scala.html: @(name: String = “Guest”)

@main(title = "Home") {
<h1>Welcome @name! </h1>
}

then from Scala class: val html = views.html.Application.hello(name)

2.0 database evolutions
conf/evolutions/${x}.sql:

# Add Post

# --- !Ups
CREATE TABLE Post (
id bigint(20) NOT NULL AUTO_INCREMENT,
title varchar(255) NOT NULL,
content text NOT NULL,
postedAt date NOT NULL,
author_id bigint(20) NOT NULL,
FOREIGN KEY (author_id) REFERENCES User(id),
PRIMARY KEY (id)
);

# --- !Downs
DROP TABLE Post;

2.0 access SQL data via Anorm
import anorm._

DB.withConnection { implicit c =>

val selectCountries = SQL("Select * from Country")

// Transform the resulting Stream[Row] to a List[(String,String)]
val countries = selectCountries().map(row =>
row[String]("code") -> row[String]("name")
).toList
}

// using Parser API
import anorm.SqlParser._

val count: Long = SQL("select count(*) from Country").as(scalar[Long].single)

val result:List[String~Int] = {
SQL("select * from Country")
.as(get[String]("name")~get[Int]("population") map { case n~p => (n,p) } *)
}

2.0 and Akka
def index = Action { // using actors, coverting Akka Future to Play Promise
Async {
(myActor ? "hello").mapTo[String].asPromise.map { response =>
Ok(response)
}
}
}

def index = Action { // execute some task asynchronously
Async {
Akka.future { longComputation() }.map { result =>
Ok("Got " + result)
}
}
}

// schedule sending message 'tick' to testActor every 30 minutes
Akka.system.scheduler.schedule(0 seconds, 30 minutes, testActor, "tick")

// schedule a single task
Akka.system.scheduler.scheduleOnce(10 seconds) {
file.delete()
}

2.0 streaming response

val file = new java.io.File("/tmp/fileToServe.pdf")
val fileContent: Enumerator[Array[Byte]] = Enumerator.fromFile(file)

SimpleResult(
header = ResponseHeader(200, Map(CONTENT_LENGTH ->
file.length.toString)),
body = fileContent
)
}

// Play has a helper for the above:

Ok.sendFile(new java.io.File("/tmp/fileToServe.pdf"))
}

2.0 chunked results

val data = getDataStream
val dataContent: Enumerator[Array[Byte]] = Enumerator.fromStream(data)

ChunkedResult(
header = ResponseHeader(200),
chunks = dataContent
)
}

// Play has a helper for the ChunkedResult above:

Ok.stream(dataContent)

2.0 Comet
lazy val clock: Enumerator[String] = {
val dateFormat = new SimpleDateFormat("HH mm ss")

Enumerator.fromCallback { () =>
Promise.timeout(Some(dateFormat.format(new Date)), 100 milliseconds)
}
}

def liveClock = Action {
Ok.stream(clock &> Comet(callback = "parent.clockChanged"))
}

and then in template:
<script type="text/javascript" charset="utf-8">
var clockChanged = function(time) { // do something }
</script>

<iframe id="comet" src="@routes.Application.liveClock.unique"></iframe>

2.0 WebSockets

just another action in controller:

def index = WebSocket.using[String] { request =>

// Log events to the console
val in = Iteratee.foreach[String](println).mapDone { _ =>
println("Disconnected")
}

// Send a single 'Hello!' message
val out = Enumerator("Hello!")

(in, out)
}

2.0 caching API
by default uses EHCache, configurable via plugins

Cache.set("item.key", connectedUser)

val user: User = Cache.getOrElse[User]("item.key") {
User.findById(connectedUser)
}

// cache HTTP response
def index = Cached("homePage",600) {
Action {
Ok("Hello world")
}
}

2.0 i18n

conf/application.conf: application.langs="en,en-US,fr"

conf/messages.en:
home.title=File viewer
files.summary=The disk {1} contains {0} file(s).

from Scala class: val title = Messages("home.title")
val titleFR = Messages("home.title")(Lang(“fr"))
val summary = Messages("files.summary", d.files.length, d.name)

from template: <h1>@Messages("home.title")</h1>

2.0 testing
…using specs2 by default
"Computer model" should {

"be retrieved by id" in {
running(FakeApplication(additionalConfiguration = inMemoryDatabase())) {

val Some(macintosh) = Computer.findById(21)

macintosh.name must equalTo("Macintosh")
macintosh.introduced must beSome.which(dateIs(_, "1984-01-24"))

}
}
}

2.0 testing templates

"render index template" in {
val html = views.html.index("Coco")

contentType(html) must equalTo("text/html")
contentAsString(html) must contain("Hello Coco")
}

2.0 testing controllers

"respond to the index Action" in {
val result = controllers.Application.index("Bob")(FakeRequest())

status(result) must equalTo(OK)
contentType(result) must beSome("text/html")
charset(result) must beSome("utf-8")
contentAsString(result) must contain("Hello Bob")
}

2.0 testing routes

"respond to the index Action" in {
val Some(result) = routeAndCall(FakeRequest(GET, "/Bob"))

status(result) must equalTo(OK)
contentType(result) must beSome("text/html")
charset(result) must beSome("utf-8")
contentAsString(result) must contain("Hello Bob")
}

2.0 testing server

"run in a server" in {
running(TestServer(3333)) {

await( WS.url("http://localhost:3333").get ).status must equalTo(OK)

}
}

2.0 testing with browser
…using Selenium WebDriver with FluentLenium

"run in a browser" in {
running(TestServer(3333), HTMLUNIT) { browser =>

browser.goTo("http://localhost:3333")
browser.$("#title").getTexts().get(0) must equalTo("Hello Guest")

browser.$("a").click()

browser.url must equalTo("http://localhost:3333/Coco")
browser.$("#title").getTexts().get(0) must equalTo("Hello Coco")

}
}

2.0 Resources

http://www.playframework.org/
https://github.com/playframework/Play20/wiki
http://www.parleys.com/#st=5&id=3143&sl=4
http://www.parleys.com/#st=5&id=3144&sl=13
http://www.parleys.com/#id=3081&st=5
http://vimeo.com/41094673

Play!ng with scala

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Play!ng with scala

Ähnlich wie Play!ng with scala (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Play!ng with scala