FP - Découverte de Play Framework Scala

Play Framework Nul ne sait qui nous sommes
Mélanie 2 janvier 2017
Kévin 4 décembre 2017
Développeurs Back-End

Play Framework Shh .. we have a plan !
La philosophie, le créateur, l’histoire
La structure d'un projet
Les configurations
Le cheminement d’une requête HTTP
Le routing
Les contrôleurs
La couche DAO avec Slick
Les tests
+ Bonus Où retrouve-t-on les
éléments du langage fonctionnel
chers à nos 💓 ?
Option / Either / Future

Play Framework Révisons sinon c’est la session 2
● Option
● Either
● Future
Option[T]
Some[T] None
Either[A, B]
Left[A, B] Right[A, B]
Future

Play Framework
open source → applications web en Java ou en Scala
φ

Play Framework C’est quoi les bails ?
2007: Guillaume Bort (Zengularity SA → Fabernovel Technologies)
Play 1.0: Mai 2008 - Octobre 2009
Play 2.0: Fin 2011 - Mars 2012 (+Sadek Drobi)
Play 2.5: Mars 2016 - Akka Streams
Play 2.6: 23 Juin 2017 - Akka HTTP serveur backend par défaut + Scala 2.12 [...]
Stateless Scala I/O asynchrones

Play Framework Les configurations
sbt
● Outil de build
● Ajout des librairies, configuration version Scala/SBT, ajout de tâches
> run
> compile
> test
> test-only maClasseDeTesterCestDouter.scala
> testQuick <mesTestsUnitairesTasVu>
> doc

/build.sbt
import Dependencies._
name := """poc-play"""
organization := "com.mrgueritte"
version := "1.0-SNAPSHOT"
scalaVersion := "2.12.6"
lazy val root = (project in file(".")).enablePlugins(PlayScala)
libraryDependencies += "com.typesafe.play" %% "play-slick-evolutions"
% "3.0.3"
resolvers += Repositories.sonatypeOss

application.conf
● Paramétrage divers : BD, Filtres, Taille buffers ...
● Format clé-valeur, HOCON
● Système héritage application.conf -> production.conf
● Injecté automatiquement dans le paramétrage de Play
● Possibilité de le charger en custom

# Database configuration
# ~~~~~
include "db.conf"
# Evolutions
# ~~~~~
play.evolutions.db.default.autoApply=true
play.evolutions.db.default.autoApplyDowns=true
# Authentication
# ~~~~~
http.secure = false

Play Framework Workflow
l’internet
mondial
Route Action Service DAO DB
HTTP Response
HTTP Request
Routeurs
Route
Contrôleurs Services

Play Framework Painless HTTP Routing
Route = HTTP Verb + URI → Controller Method
# Routes
# This files defines all application routes (Higher priority routes first)
# https://www.playframwork.com/documentation/latest/ScalaRouting
# ~~~~
GET /api/cat/:id controllers.CatsController.get(id: CatId)
-> / order.Routes
-> / owner.Routes

Play Framework Les routeurs exemples
GET /clients/:id controllers.Clients.show(id: Long)
GET /api/list-all controllers.Api.list(version: Option[String])
GET /items/$id<[0-9]+> controllers.Items.show(id: Long)
GET / controllers.Application.show(page = "home")
GET /:page controllers.Application.show(page)
GET /clients controllers.Clients.list(page: Int ?= 1)
GET /api/cat/:id controllers.CatsController.get(id: CatId) ?

Play Framework Painless HTTP Routing
case class CatId(id: UUID)

Play Framework Router Tunning Custom
/build.sbt routesImport ++= "utils.RoutesParser._" :: "utils.CatId" :: Nil
/RoutesParser.scala
object RoutesParser {
implicit object parameterBindableCatId extends PathBindable[CatId] {
override def bind(key: String, catIdStr: String): Either[String, CatId] = {
Try(CatId(UUID.fromString(catIdStr))) match {
case Success(catId) => Right(catId)
case Failure(e) => Left(s"Cannot parse parameter $key as CatId: $e")
}
}
override def unbind(key: String, catId: CatId): String = catId.id.toString
}
}
Exemple d’UUID: 89a7df10-284f-415c-b52a-427acf4c31ae

Play Framework Workflow
Route Action Service DAO DB
HTTP Response
HTTP Request
Routeurs
Route
Contrôleurs Services

Play Framework Dans les contrôleurs y a de l’action
play.api.mvc.Request =>
play.api.mvc.Result
val echo = Action { request =>
Ok(s"Got request [$request]")
}

Action { Ok("Hello world") }
def hello(name: String) = Action {
Ok("Hello " + name)
}
def echo = Action { request =>
Ok("Got request [" + request + "]")
}
def createHouse() = Action(parse.json[House]) {request =>
Ok(request.body)//House
}

def createHouseAsync = Action().async { request =>
for {
design <- getPlans()
wood <- getMaterial()
} yield Ok(Json.obj("House plans" -> design, "material" -> wood))
}

Play Framework Authentification
Support pour OAuth2
Guest
Member
OrganizationMember.(Read)
PlatformAdmin
Api(Scope)
[...]
def list() = OrganizationMember(READ)("cats.list").async { implicit request =>
catsService
.listByOrganization(request.organizationId)
.map(Ok(_))
}
=> Future[Result]

Play Framework Les resultats c’est pas du bois
Ok("Hello World!")
→ Content-Type header to text/plain
Ok(<message>Hello World!</message>)
→ application/xml
Ok(<h1>Hello World!</h1>)
→ application/html
Ok(Json.obj(”foo” -> “bar”)) -> application/json
val result = Ok("Hello World!").withHeaders(
CACHE_CONTROL -> "max-age=3600",
ETAG -> "xx")

Play Framework Les resultats c’est pas du bois

Play Framework Les configurations de Slick
val slick = "com.typesafe.play” %% "play-slick" % Version.slickVersion
val slickEvolution = "com.typesafe.play" %% "play-slick-evolutions" % Version.slickVersion
/build.sbt
/application.conf
slick.dbs.default.profile = "slick.jdbc.H2Profile$"
slick.dbs.default.db.driver = "org.h2.Driver"
slick.dbs.default.db.url = "jdbc:h2:mem:play;DATABASE_TO_UPPER=false"
slick.dbs.default.profile = "slick.jdbc.PostgresProfile$"
slick.dbs.default.db.user = "user"
slick.dbs.default.db.password = "pswd"

Play Framework Les schémas
object Schemas extends EntityMappers {
class Cats(tag: Tag) extends Table[Cat](tag, "cats") {
def catId = column[CatId]("id")
def name = column[String]("name")
def pedigreeId = column[PedigreeId]("pedigree_id")
def gender = column[Gender]("gender")
def owner = column[Option[OwnerId]]("owner_id")
def dateOfBirth = column[Date]("date_of_birth")
def dateOfDeath = column[Option[Date]]("date_of_death")
override def * =
(catId, name, pedigreeId, gender, owner, dateOfBirth, dateOfDeath) <> (Cat.tupled, Cat.unapply)
}
...
val cats = TableQuery[Cats]
}

Play Framework Les requêtes : “tout est
collection”> SELECT * FROM cats WHERE id = ?
override def getById(id: CatId): DBIO[Option[Cat]] = Schemas.cats.filter(_.id === id).headOption
> INSERT INTO cats VALUES (?,?,? …)
override def create(cat: Cat): DBIO[Unit] = Schemas.cats += cat
> SELECT c.* FROM pedigrees p JOIN cat c ON c.pedigreeId = p.id WHERE p.name = ?
override def getByPedigreeName(name: String): DBIO[Seq[Cat]] = {
for {
cat <- Schemas.cats
pedigree <- Schemas.pedigrees
if pedigree.id === cat.pedigreeId && pedigree.pedigree === name
} yield cat
}

Play Framework Les DBIO
override def getByPedigreeName(name: String): Future[Seq[Cat]] = {
val transaction = (for {
cat <- catsDAO.getByPedigreeName(name)
_ <- DBIO.seq(cat.map(c => catsDAO.delete(c.catId)): _*)
} yield cat).transactionally
db.run(transaction)
}
> Les compositions de requêtes & les transactions

Play Framework Les évolutions
● Situé dans le dossier /conf/evolutions/<dbName>/
● Chaque script est composé de deux parties :
○ Ups! : SQL d’évolution de la BD (INSERT, CREATE …)
○ Downs! : Retour arrière de l’évolution (DROP, ALTER …)
● Une table `play_evolutions` est créée sur la DB => versionnage
# --- !Ups
CREATE TABLE pedigrees(
id UUID NOT NULL,
name VARCHAR(32) NOT NULL
);
…
# --- !Downs
DROP TABLE cats;
DROP TABLE owners;
DROP TABLE pedigrees;

Play Framework Les évolutions, “j’ai tout casséhéhé”
● Modification du script en question
● Marquer le script comme résolu => Application du `!Downs` puis du `!Ups`

Play Framework Injections de dépendances
● Guice est embarqué => utilisation à spécifier build.sbt
● Auto-gestion des dépendances avec @Inject() (java !)
● Runtime
“Use another compile time dependency injection!”

ApplicationLoader
● Point entrée unique facilement customisable => `application.conf`
● Chargement de toutes les “parties” de l’application => `Components`
class PocPlayApplicationLoader extends ApplicationLoader {
override def load(context: Context): Application = {
new PocPlayComponents(context).application
}
}
play.application.loader= "di.PocPlayApplicationLoader"

Components
class PocPlayComponents(context: Context) extends
BuiltInComponentsFromContext(context)
with HttpFiltersComponents // Add defaults HTTP Filters
with SlickComponents // Add Slick API (connect play to database)
with EvolutionsComponents { // Add Evolutions system
override lazy val dbApi: DBApi = SlickDBApi(slickApi)
applicationEvolutions.start()
...
}

PlayFramework On a parcouru le chemin, on a tenu la distance
class CatsController( catsService: CatsService [...]
def buy(catId: CatId, ownerId: OwnerId) = Action.async { implicit request =>
catsService.buy(catId, ownerId)[...] }
class CatsServiceImpl( catsDAO: CatsDAO, db: DbExecutor [...]
override def buy(catId: CatId, ownerId: OwnerId): Future[Either[ApiError, Void]] =
[...] db.run(catsDAO.updateOwner(catId, ownerId)) [...]
case class CatsDAOSlick()(implicit ec: ExecutionContext) extends CatsDAO {
override def updateOwner(catId: CatId, ownerId: OwnerId): DBIO[Void] = [...]

Components - Add dependency injection with macwire
class PocPlayComponents(context: Context) extends
BuiltInComponentsFromContext(context)
with HttpFiltersComponents // Add defaults HTTP Filters
with SlickComponents // Add Slick API (connect play to database)
with EvolutionsComponents { // Add Evolutions system
...
lazy val db: DbExecutor =
slickApi.dbConfig[JdbcProfile](DbName("default")).db
lazy val catsDAO: CatsDAO = new CatsDAOSlick()
lazy val catsService: CatsService = wire[CatsServiceImpl]
lazy val catsController: CatsController = wire[CatsController]
}

Play Framework Tests
Scala Test - Flat Spec et d’autres WordSpec/FreeSpec etc.
class HelloWorldSpec extends Specification {
"The 'Hello world' string" should {
"contain 11 characters" in {
"Hello world" must have size(11)
}
"start with 'Hello'" in {
"Hello world" must startWith('Hello')
}
}
}
[info] HelloWorldSpec:
[info] The 'Hello world' string
[info] - should contain 11 characters
[info] - should start with 'Hello'
[info] ScalaTest
[info] Run completed in 2 seconds, 888 milliseconds.
[info] Total number of tests run: 2
[info] Suites: completed 1, aborted 0
[info] Tests: succeeded 2, failed 0, canceled 0,
ignored 0, pending 0
[info] All tests passed.
[info] Passed: Total 2, Failed 0, Errors 0, Passed 2
[success] Total time: 5 s, completed 3 juin 2018
22:13:54

Mock API’s
import play.api.test.Helpers._
class CatsApiSpec extends PocPlayOneAppPerSuite {
…
def createCatApi(body: JsValue) = FakeRequest("POST", "/api/cats").withBody(body)
"Cats API" must {
"have a valid endpoint `create cat API`" in {
...
val Some(response) = route(app, createCatApi(catsBody))
status(response) == CREATED
val json = contentAsJson(response)
...
}
}
}

Mock context
trait PocPlayOneAppPerSuite extends PlaySpec with GuiceOneAppPerSuite { self =>
override lazy val app = {
val context = ApplicationLoader.createContext(new Environment(new java.io.File("."),
ApplicationLoader.getClass.getClassLoader, Mode.Test))
new TestComponents(context).application
}
}
class TestComponents(context: Context) extends PocPlayComponents(context: Context) {
override lazy val configuration = {
val databseConfig = ConfigFactory.parseString(
"""slick.dbs.default.db.url = <database test>""".stripMargin)
context.initialConfiguration.copy(underlying = databseConfig)
}
}

Play Framework Fun with tests
Property-based testing - Scala Check
def catJsonGenerator: Gen[JsObject] = {
for {
name <- Gen.alphaStr.suchThat(_.size < 32)
gender <- Gen.oneOf(const(Gender.Female), const(Gender.Male))
pedigreeId <- const(PedigreeId(UUID.fromString("cc58095b-8d51-4a22-a110-7ace2d921c2c")))
ownerId <- option(const(OwnerId(UUID.fromString("76065e7d-8604-4995-a6ed-33fca30517aa"))))
dateOfBirth <- const(DateTime.now())
} yield buildCatJson(name, gender, pedigreeId, ownerId, dateOfBirth, None)
}
"have a valid endpoint `create cat API`" in {
check {
Prop.forAll(catJsonGenerator) { catsBody: JsObject =>
val Some(response) = route(app, createCatApi(catsBody))
status(response) == CREATED
}
}
}

Play Framework Vous en profitez sans le savoir

Play Framework Merci d’être là, super sympa
https://github.com/kevin-margueritte/poc-playframework
Des questions ?
Vous êtes sûrs ? On va être coupés, y a un tunnel.

FP - Découverte de Play Framework Scala

Related slideshows

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

More Related Content

What's hot

What's hot (20)

Similar to FP - Découverte de Play Framework Scala

Similar to FP - Découverte de Play Framework Scala (20)

Recently uploaded

Recently uploaded (20)

FP - Découverte de Play Framework Scala

Editor's Notes