Comment implémenter les rappels de cycle de vie de play framework (2.5.x)

Question

J'essaie d'apprendre le cadre de jeu. Je veux implémenter les callbacks de cycle de vie du cadre de jeu dans mon application. Maintenant, je l'ai vu qu'il peut être facilement fait en utilisant GlobalSettings ci-dessous:

object Global extends GlobalSettings { 

    override def onStart(app: Application) { 
    Logger.info("Application has started") 
    } 

    override def onStop(app: Application) { 
    Logger.info("Application shutdown...") 
    } 

} 

Mais il a été dépréciée dans le cadre de jeu (2.5.x). Et ils fournissent une liaison désirée pour onStart rappels et pour onStop et onError il existe d'autres mécanismes. J'ai regardé dans la documentation de la version 2.5.x et j'ai vu un code comme ci-dessous:

import com.google.inject.AbstractModule 
import com.google.inject.name.Names 

class Module extends AbstractModule { 
    def configure() = { 

    bind(classOf[Hello]) 
     .annotatedWith(Names.named("en")) 
     .to(classOf[EnglishHello]).asEagerSingleton 

    bind(classOf[Hello]) 
     .annotatedWith(Names.named("de")) 
     .to(classOf[GermanHello]).asEagerSingleton 
    } 
} 

Mais malheureusement, je ne pouvais pas le comprendre. En utilisant GlobalSettings, il était assez facile d'implémenter les rappels de cycle de vie. Supposons que je vais juste implémenter une info Logger dans les callbacks du cycle de vie. Pas de codes complexes.
Comment puis-je implémenter ceci pour les rappels de début, d'arrêt et d'erreur dans 2.5.x ??

Answer 1

En général, avoir éloigné ces mécanismes de GlobalSettings signifie également que vous n'enregistrez plus ces 'callbacks' globalement, mais que vous les attachez à un composant/classe. Cela donne l'avantage que l'initialisation et l'arrêt d'un certain composant peuvent se produire directement dans la classe respective. Toutefois, si vous avez du code que vous voulez exécuter au démarrage (ou à l'arrêt) qui n'est pas lié à un composant spécifique (par exemple, journalisation, contrôles de démarrage, etc.), vous devrez créer de nouvelles classes et les lier dans votre module. Notez que dans ce dernier cas, vous liez typiquement les classes respectives comme des singletons impatients (pour être sûr qu'ils sont instanciés) alors que dans le premier cas, les classes sont instanciées comme faisant partie de l'arbre de dépendance.

Démarrage: Exécute du code dans le constructeur de n'importe quelle classe gérée par le conteneur d'injection de dépendances.

1. classe Bind dans le module

bind(classOf[Hello]).to(classOf[EnglishHello]).asEagerSingleton 

2. code Put dans le constructeur

class EnglishHello extends Hello { 
    println("hello") 
} 

Notez que la asEagerSingleton n'est pas nécessaire en soi . Comme je suppose que vous utilisez comme guide de DI-fournisseur, vous pouvez en savoir plus à ce sujet ici: https://github.com/google/guice/wiki/Scopes

Arrêt: Dans une classe qui a besoin d'exécuter un code d'arrêt, enregistrer un rappel du cycle de vie. 1. Bind classe dans le module

bind(classOf[Hello]).to(classOf[EnglishHello]).asEagerSingleton 

2. registre rappel du cycle de vie (et injecter ApplicationLifecycle)

class EnglishHello @Inject() (lifecycle: ApplicationLifecycle) extends Hello { 
    lifecycle.addStopHook {() => 
    Future.successful(connection.stop()) 
    } 
} 

Notez que vous pouvez la portée de ces classes que singletons, sinon vous finissez par enregistrer des points d'arrêt pour chaque instance - en fonction de ce que vous arrêtez de faire, cela peut être ce que vous voulez.En savoir plus à ce sujet ici: https://www.playframework.com/documentation/2.5.x/ScalaDependencyInjection#Stopping/cleaning-up

Erreurs: Implémentez votre propre HttpErrorHandler. L'idée de base est que vous implémentez une classe avec un certain nombre de méthodes qui seront appelées par Play! sur les erreurs respectives. Ceci est documenté ici: https://www.playframework.com/documentation/2.5.x/ScalaErrorHandling