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

Definition Classes: api

package test

Contains test helpers.

Definition Classes: api

Application

ApplicationLoader

BuiltInComponents

BuiltInComponentsFromContext

ConfigLoader

Configuration

DefaultApplication

DefaultMarkerContext

Environment

Logger

LoggerConfigurator

LoggerLike

Logging

LowPriorityMarkerContextImplicits

MarkerContext

MarkerContexts

Mode

NoHttpFiltersComponents

OptionalDevContext

OptionalSourceMapper

OptionalSourceMapperProvider

Play

UnexpectedException

play.api

Application

Companion object Application

trait Application extends AnyRef

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( ... )
Source: Application.scala

Linear Supertypes

AnyRef, Any

Known Subclasses

DefaultApplication

Ordering

Alphabetic
By Inheritance

Inherited

Application
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Abstract Value Members

abstract def actorSystem: ActorSystem
The default ActorSystem used by the application.
abstract def classloader: ClassLoader
The application's classloader
abstract def configuration: Configuration
abstract def coordinatedShutdown: CoordinatedShutdown
The default CoordinatedShutdown to stop the Application
abstract def environment: Environment
The application's environment
abstract def errorHandler: HttpErrorHandler
The HTTP error handler
implicit abstract def materializer: Materializer
The default Materializer used by the application.
abstract def path: File
The absolute path hosting this application, mainly used by the getFile(path) helper method
abstract def requestFactory: RequestFactory
The factory used to create requests for this application.
abstract def requestHandler: HttpRequestHandler
The HTTP request handler
abstract def stop(): Future[_]
Stop the application.
Stop the application. The returned future will be redeemed when all stop hooks have been run.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asJava: play.Application
Return the application as a Java application.
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
lazy val globalApplicationEnabled: Boolean
Returns true if the global application is enabled for this app.
Returns true if the global application is enabled for this app. If set to false, this changes the behavior of Play.start to disallow access to the global application instance, also affecting the deprecated Play APIs that use these.
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
def injector: Injector
Get the runtime injector for this application.
Get the runtime injector for this application. In a runtime dependency injection based application, this can be used to obtain components as bound by the DI framework.
returns
The injector.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mode: Mode
Dev, Prod or Test
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()

Packages

Play

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Application

Companion object Application

trait Application extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Play

Read configuration

Use the logger

Define a Plugin

Create adhoc applications (for testing)

Application 

Companion object Application

trait Application extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Application