Consider that our application has the following specifications:

Play provides methods that allow us to hook into the application's life cycle and complete such tasks. The GlobalSettings trait has methods that assist in doing so. These can be overridden by the Global object, if required.

To cater to the specifications of the application described earlier, all we need to do in a Play application is define a Global object, as shown here:

object Global extends GlobalSettings {

  override def beforeStart(app: Application): Unit = {
    ResourceHandler.initialize
  }
  
  override def onStart(app: Application):Unit={
    DBHandler.createSchema
  }

  override def onStop(app: Application): Unit = {
    Mailer.sendLogs
  }
}

The ResourceHandler.initialize, DBHandler.createSchema, and Mailer.sendLogs methods are specific to our application and are defined by us, not provided by Play.

Now that we know how to hook into the application's life cycle, let's scrutinize how it works.

Digging deeper into the application's life cycle we can see that all the implementations of ApplicationProvider use the Play.start method to initialize an application. The Play.start method is defined as follows:

def start(app: Application) {

    // First stop previous app if exists
    stop()

    _currentApp = app

    // Ensure routes are eagerly loaded, so that the reverse routers are correctly
    // initialized before plugins are started.
    app.routes
    Threads.withContextClassLoader(classloader(app)) {
      app.plugins.foreach(_.onStart())
    }

    app.mode match {
      case Mode.Test =>
      case mode => logger.info("Application started (" + mode + ")")
    }

  }

This method ensures that each plugin's onStart method is called right after the application is set as _currentApp. GlobalPlugin, is added by default to all the Play applications, and is defined as:

class GlobalPlugin(app: Application) extends Plugin {

  // Call before start now
  app.global.beforeStart(app)

  // Called when the application starts.
  override def onStart() {
    app.global.onStart(app)
  }

  //Called when the application stops.
  override def onStop() {
    app.global.onStop(app)
  }

}

In the preceding snippet, app.global refers to the GlobalSettings defined for the application. Therefore, the GlobalPlugin ensures that the appropriate methods of the application's GlobalSettings are called.

The beforeStart method is called on initialization of the plugin.

Now, we just need to figure out how onStop is called. Once an application is stopped, ApplicationProvider does not have control, so the Java runtime shutdown hook is used to ensure that certain tasks are executed once the application is stopped. Here is a look at the relevant lines from the NettyServer.createServer method:

Runtime.getRuntime.addShutdownHook(new Thread { 
        override def run { 
          server.stop() 
        } 
      })

Here, runtime is java.lang.Runtime (Java docs for the same are available at http://docs.oracle.com/javase/7/docs/api/java/lang/Runtime.html) and the server is an instance of NettyServer. NettyServer's stop method is defined as:

override def stop() {

    try {
      Play.stop()
    } catch {
      case NonFatal(e) => Play.logger.error("Error while stopping the application", e)
    }

    try {
      super.stop()
    } catch {
      case NonFatal(e) => Play.logger.error("Error while stopping logger", e)
    }

    mode match {
      case Mode.Test =>
      case _ => Play.logger.info("Stopping server...")
    }

    // First, close all opened sockets
    allChannels.close().awaitUninterruptibly()

    // Release the HTTP server
    HTTP.foreach(_._1.releaseExternalResources())

    // Release the HTTPS server if needed
    HTTPS.foreach(_._1.releaseExternalResources())

    mode match {
      case Mode.Dev =>
        Invoker.lazySystem.close()
        Execution.lazyContext.close()
      case _ => ()
    }
  }

Here, the Invoker.lazySystem.close() call is used to shut down the ActorSystem used internally within a Play application. The Execution.lazyContext.close() call is to shut down Play's internal ExecutionContext.

The Play.stop method is defined as follows:

 def stop() {
    Option(_currentApp).map { app =>
      Threads.withContextClassLoader(classloader(app)) {
        app.plugins.reverse.foreach { p =>
          try {
            p.onStop()
          } catch { case NonFatal(e) => logger.warn("Error stopping plugin", e) }
        }
      }
    }
    _currentApp = null
  }

This method calls the onStop method of all the registered plugins in reverse order, so the GlobalPlugin's onStop method is called and it eventually calls the onStop method of the GlobalSetting defined for the application. Any errors encountered in this process are logged as warnings since the application is going to be stopped.

We can now add any task within the application's life cycle, such as creating database schemas before starting, initializing global objects, or scheduling jobs (using Akka Scheduler or Quartz, and so on) on starting and cleaning temporary data when stopping.

We've covered the application's life cycle, now let's look into the request-response life cycle.