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.
A full configuration set.
A full configuration set.
The underlying implementation is provided by https://github.com/typesafehub/config.
the underlying Config implementation
The Global plugin executes application's globalSettings onStart and onStop.
Defines an application’s global settings.
Defines an application’s global settings.
To define your own global settings, just create a Global object in the _root_ package.
object Global extends GlobalSettings { override def onStart(app: Application) { Logger.info("Application is started!!!") } }
A Play logger.
Typical logger interface.
A Play plugin.
A Play plugin.
A plugin must define a single argument constructor that accepts an play.api.Application. For example:
class MyPlugin(app: Application) extends Plugin { override def onStart() = { Logger.info("Plugin started!") } }
The plugin class must be declared in a play.plugins file available in the classpath root:
1000:myapp.MyPluginThe associated int defines the plugin priority.
Generic exception for unexpected error cases.
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/typesafehub/config.
The default global settings if not defined in the application.
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!")
Application mode, either DEV, TEST, or PROD.
High-level API to access Play global features.
High-level API to access Play global features.
Note that this API depends on a running application. You can import the currently running application in a scope using:
import play.api.Play.current
Helper utilities related to Router.
Contains the Cache access API.
Contains data manipulation helpers (typically HTTP form handling)
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 ) )
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")
Contains standard HTTP constants.
Contains standard HTTP constants. For example:
val text = ContentTypes.TEXT val ok = Status.OK val accept = HeaderNames.ACCEPT
Contains the internationalisation API.
Contains the internationalisation API.
For example, translating a message:
val msgString = Messages("items.found", items.size)
Contains various APIs that are useful while developing web applications.
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:
object Application extends Controller { def index = Action { Ok("It works!") } }
Contains Template adapters for typical Play applications.
Contains test helpers.
Contains the public API for Scala developers.
Access the current Play application
import play.api.Play.currentRead configuration
Use the logger
Logger.info("Hello!")Define a Plugin
Create adhoc applications (for testing)