api
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 Java and Scala default implementation based on Guice. The Scala implementation is the play.api.inject.guice.GuiceApplicationLoader.
A custom application loader can be configured using the application.loader configuration property.
Implementations must define a no-arg constructor.
A full configuration set.
A full configuration set.
The underlying implementation is provided by https://github.com/typesafehub/config.
the underlying Config implementation
compare-to-play.md
The environment for the application.
The environment for the application.
Captures concerns relating to the classloader and the filesystem for the application.
The root path that the application is deployed at.
The classloader that all application classes and resources can be loaded from.
The mode of the application.
A Play logger.
Typical logger interface.
compare-to-play.md
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.
compare-to-play.md 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.
compare-to-play.md 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
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.
The Module class for information on how to provide bindings.
compare-to-play.md 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:
This will create an application using the current classloader.