Packages

package root

Definition Classes: root

package play

Play framework.

Play

http://www.playframework.com

Definition Classes: root

package api

Contains the public API for Scala developers.

Read configuration

val poolSize = configuration.getInt("engine.pool.size")

Use the logger

Logger.info("Hello!")

Define a Plugin

class MyPlugin(app: Application) extends Plugin

Create adhoc applications (for testing)

val application = Application(new File("."), this.getClass.getClassloader, None, Play.Mode.DEV)

Definition Classes: play

package cache

Contains the Cache access API.

Definition Classes: api

package cluster

Definition Classes: api

package controllers

Definition Classes: api

package data

Contains data manipulation helpers (typically HTTP form handling)

import play.api.data._
import play.api.data.Forms._

val taskForm = Form(
  tuple(
    "name" -> text(minLength = 3),
    "dueDate" -> date("yyyy-MM-dd"),
    "done" -> boolean
  )
)

Definition Classes: api

package db

Contains the JDBC database access API.

Example, retrieving a connection from the 'customers' datasource:

val conn = db.getConnection("customers")

Definition Classes: api

package http

Contains standard HTTP constants.

Contains standard HTTP constants. For example:

val text = ContentTypes.TEXT
val ok = Status.OK
val accept = HeaderNames.ACCEPT

Definition Classes: api

package i18n

Contains the internationalisation API.

For example, translating a message:

val msgString = Messages("items.found", items.size)

Definition Classes: api

package inject

Play's runtime dependency injection abstraction.

Play's runtime dependency injection support is built on JSR-330, which provides a specification for declaring how dependencies get wired to components. JSR-330 however does not address how components are provided to or located by a DI container. Play's API seeks to address this in a DI container agnostic way.

The reason for providing this abstraction is so that Play, the modules it provides, and third party modules can all express their bindings in a way that is not specific to any one DI container.

Components are bound in the DI container. Each binding is identified by a BindingKey, which is typically an interface that the component implements, and may be optionally qualified by a JSR-330 qualifier annotation. A binding key is bound to a BindingTarget, which describes how the implementation of the interface that the binding key represents is constructed or provided. Bindings may also be scoped using JSR-330 scope annotations.

Bindings are provided by instances of Module.

Out of the box, Play provides an implementation of this abstraction using Guice.

Definition Classes: api
See also: The Module class for information on how to provide bindings.

package internal

Definition Classes: api

package libs

Contains various APIs that are useful while developing web applications.

Definition Classes: api

package mvc

Contains the Controller/Action/Result API to handle HTTP requests.

For example, a typical controller:

class HomeController @Inject() (val controllerComponents: ControllerComponents) extends BaseController {

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

}

Definition Classes: api

package routing

Definition Classes: api

package sird

The Play "String Interpolating Routing DSL", sird for short.

This provides: - Extractors for requests that extract requests by method, eg GET, POST etc. - A string interpolating path extractor - Extractors for binding parameters from paths to various types, eg int, long, double, bool.

The request method extractors return the original request for further extraction.

The path extractor supports three kinds of extracted values: - Path segment values. This is the default, eg p"/foo/$id". The value will be URI decoded, and may not traverse /'s. - Full path values. This can be indicated by post fixing the value with a *, eg p"/assets/$path*". The value will not be URI decoded, as that will make it impossible to distinguish between / and %2F. - Regex values. This can be indicated by post fixing the value with a regular expression enclosed in angle brackets. For example, p"/foo/$id<[0-9]+>. The value will not be URI decoded.

The extractors for primitive types are merely provided for convenience, for example, p"/foo/${int(id)}" will extract id as an integer. If id is not an integer, the match will simply fail.

Example usage:

import play.api.routing.sird._
import play.api.routing._
import play.api.mvc._

Router.from {
  case GET(p"/hello/$to") => Action {
    Results.Ok(s"Hello $to")
  }
  case PUT(p"/api/items/${int(id)}") => Action.async { req =>
    Items.save(id, req.body.json.as[Item]).map { _ =>
      Results.Ok(s"Saved item $id")
    }
  }
}

HandlerDef

JavaScriptReverseRoute

JavaScriptReverseRouter

Router

SimpleRouter

SimpleRouterImpl

package templates

Definition Classes: api

package test

Contains test helpers.

Definition Classes: api

play.api

routing

package routing

Ordering

Alphabetic

Visibility

Public
Protected

Package Members

package sird
The Play "String Interpolating Routing DSL", sird for short.
The Play "String Interpolating Routing DSL", sird for short.
This provides: - Extractors for requests that extract requests by method, eg GET, POST etc. - A string interpolating path extractor - Extractors for binding parameters from paths to various types, eg int, long, double, bool.
The request method extractors return the original request for further extraction.
The path extractor supports three kinds of extracted values: - Path segment values. This is the default, eg p"/foo/$id". The value will be URI decoded, and may not traverse /'s. - Full path values. This can be indicated by post fixing the value with a *, eg p"/assets/$path*". The value will not be URI decoded, as that will make it impossible to distinguish between / and %2F. - Regex values. This can be indicated by post fixing the value with a regular expression enclosed in angle brackets. For example, p"/foo/$id<[0-9]+>. The value will not be URI decoded.
The extractors for primitive types are merely provided for convenience, for example, p"/foo/${int(id)}" will extract id as an integer. If id is not an integer, the match will simply fail.
Example usage:
```
import play.api.routing.sird._
import play.api.routing._
import play.api.mvc._

Router.from {
  case GET(p"/hello/$to") => Action {
    Results.Ok(s"Hello $to")
  }
  case PUT(p"/api/items/${int(id)}") => Action.async { req =>
    Items.save(id, req.body.json.as[Item]).map { _ =>
      Results.Ok(s"Saved item $id")
    }
  }
}
```

Type Members

case class HandlerDef(classLoader: ClassLoader, routerPackage: String, controller: String, method: String, parameterTypes: Seq[Class[_]], verb: String, path: String, comments: String = "", modifiers: Seq[String] = Seq.empty) extends routing.HandlerDef with Product with Serializable
Information about a Handler, especially useful for loading the handler with reflection.
case class JavaScriptReverseRoute(name: String, f: String) extends Product with Serializable
A JavaScript reverse route
trait Router extends AnyRef
A router.
trait SimpleRouter extends Router
A simple router that implements the withPrefix and documentation methods for you.
class SimpleRouterImpl extends SimpleRouter

Value Members

object JavaScriptReverseRouter
object Router
Utilities for routing.
object SimpleRouter

Packages

Play

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

routing

package routing

Package Members

Type Members

Value Members

Ungrouped

routing