api

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)

Source: package.scala

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

api
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Package Members

package cache
Contains the Cache access API.
package cluster
package controllers

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

package db
Contains the JDBC database access API.
Contains the JDBC database access API.
Example, retrieving a connection from the 'customers' datasource:
```
val conn = db.getConnection("customers")
```
package http
Contains standard HTTP constants.
Contains standard HTTP constants. For example:
```
val text = ContentTypes.TEXT
val ok = Status.OK
val accept = HeaderNames.ACCEPT
```
package i18n
Contains the internationalisation API.
Contains the internationalisation API.
For example, translating a message:
```
val msgString = Messages("items.found", items.size)
```
package inject
Play's runtime dependency injection abstraction.
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.
See also
The Module class for information on how to provide bindings.
package internal
package libs
Contains various APIs that are useful while developing web applications.
package mvc
Contains the Controller/Action/Result API to handle HTTP requests.
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!")
  }

}
```
package routing
package templates
package test
Contains test helpers.

Type Members

trait Application extends AnyRef
A Play application.
A Play application.
Application creation is handled by the framework engine.
If you need to create an ad-hoc application, for example in case of unit testing, you can easily achieve this using:
```
val application = new DefaultApplication(new File("."), this.getClass.getClassloader, None, Play.Mode.Dev)
```
This will create an application using the current classloader.
Annotations
@implicitNotFound()
trait ApplicationLoader extends AnyRef
Loads an application.
Loads an application. This is responsible for instantiating an application given a context.
Application loaders are expected to instantiate all parts of an application, wiring everything together. They may be manually implemented, if compile time wiring is preferred, or core/third party implementations may be used, for example that provide a runtime dependency injection framework.
During dev mode, an ApplicationLoader will be instantiated once, and called once, each time the application is reloaded. In prod mode, the ApplicationLoader will be instantiated and called once when the application is started.
Out of the box Play provides a Guice module that defines a Java and Scala default implementation based on Guice, as well as various helpers like GuiceApplicationBuilder. This can be used simply by adding the "PlayImport.guice" dependency in build.sbt.
A custom application loader can be configured using the play.application.loader configuration property. Implementations must define a no-arg constructor.
trait BuiltInComponents extends I18nComponents with AkkaComponents with AkkaTypedComponents
Helper to provide the Play built in components.
abstract class BuiltInComponentsFromContext extends ContextBasedBuiltInComponents
This helper class provides all the built-in component dependencies by trading them for a single dependency - the application loader context.
trait ConfigLoader[A] extends AnyRef
A config loader
case class Configuration(underlying: Config) extends Product with Serializable
A full configuration set.
A full configuration set.
The underlying implementation is provided by https://github.com/lightbend/config.
underlying
the underlying Config implementation
trait ContextBasedBuiltInComponents extends BuiltInComponents
This helper trait provides all the built-in component dependencies by trading them for a single dependency - the application loader context.
class DefaultApplication extends Application
Annotations
@Singleton()
class DefaultMarkerContext extends MarkerContext
A default marker context.
A default marker context. This is used by MarkerContext.apply, but can also be used to provide explicit typing for markers. For example, to define a SecurityContext marker, you can define a case object extending DefaultMarkerContext:
```
case object SecurityMarkerContext extends DefaultMarkerContext(MarkerFactory.getMarker("SECURITY"))
```
case class Environment(rootPath: File, classLoader: ClassLoader, mode: Mode) extends Product with Serializable
The environment for the application.
The environment for the application.
Captures concerns relating to the classloader and the filesystem for the application.
rootPath
The root path that the application is deployed at.
classLoader
The classloader that all application classes and resources can be loaded from.
mode
The mode of the application.
class Logger extends LoggerLike
A Play logger.
trait LoggerConfigurator extends AnyRef
Runs through underlying logger configuration.
trait LoggerLike extends AnyRef
Typical logger interface.
trait Logging extends AnyRef
A trait that can mixed into a class or trait to add a logger named based on the class name.
trait LowPriorityMarkerContextImplicits extends AnyRef
trait MarkerContext extends AnyRef
A MarkerContext trait, to provide easy access to org.slf4j.Marker in Logger API.
A MarkerContext trait, to provide easy access to org.slf4j.Marker in Logger API. This is usually accessed with a marker through an implicit conversion from a Marker.
```
implicit val markerContext: MarkerContext = org.slf4j.MarkerFactory.getMarker("EXAMPLEMARKER")
log.error("This message will be logged with the EXAMPLEMARKER marker")
```
sealed abstract class Mode extends AnyRef
Application mode, either Dev, Test, or Prod.
Application mode, either Dev, Test, or Prod.
See also
play.Mode
trait NoHttpFiltersComponents extends AnyRef
A component to mix in when no default filters should be mixed in to BuiltInComponents.
A component to mix in when no default filters should be mixed in to BuiltInComponents.
See also
BuiltInComponents.httpFilters
final class OptionalDevContext extends AnyRef
Represents an Option[DevContext] so that it can be used for dependency injection.
Represents an Option[DevContext] so that it can be used for dependency injection. We can't easily use a plain Option[DevContext] since Java erases the type parameter of that type.
final class OptionalSourceMapper extends AnyRef
Represents an Option[SourceMapper] so that it can be used for dependency injection.
Represents an Option[SourceMapper] so that it can be used for dependency injection. We can't easily use a plain Option[SourceMapper] since Java erases the type parameter of that type.
final class OptionalSourceMapperProvider extends Provider[OptionalSourceMapper]
Annotations
@Singleton()
case class UnexpectedException(message: Option[String] = None, unexpected: Option[Throwable] = None) extends PlayException with Product with Serializable
Generic exception for unexpected error cases.

Value Members

object Application
object ApplicationLoader
object ConfigLoader
object Configuration extends Serializable
This object provides a set of operations to create Configuration values.
This object provides a set of operations to create Configuration values.
For example, to load a Configuration in a running application:
```
val config = Configuration.load()
val foo = config.getString("foo").getOrElse("boo")
```
The underlying implementation is provided by https://github.com/lightbend/config.
object Environment extends Serializable
object Logger
High-level API for logging operations.
High-level API for logging operations.
For example, logging with the default application logger:
```
Logger.info("Hello!")
```
Logging with a custom logger:
```
Logger("my.logger").info("Hello!")
```
object LoggerConfigurator
object MarkerContext extends LowPriorityMarkerContextImplicits
object MarkerContexts
object Mode
object Play
High-level API to access Play global features.

Packages

Play

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

api

package api

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Package Members

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Play

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

api

package api

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Package Members

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

api