scala - Play Framework: Dependency Inject Action Builder

playframework dependency-injection

Question

Desde Play Framework 2.4 existe la posibilidad de usar inyección de dependencia (con Guice).

Antes de usar objetos (por ejemplo, AuthenticationService ) en mis ActionBuilders:

object AuthenticatedAction extends ActionBuilder[AuthenticatedRequest] {
  override def invokeBlock[A](request: Request[A], block: (AuthenticatedRequest[A]) => Future[Result]): Future[Result] = {
    ...
    AuthenticationService.authenticate (...)
    ...
  }
}

Ahora AuthenticationService ya no es un objeto, sino una clase. ¿Cómo puedo seguir usando el servicio de AuthenticationService en mi ActionBuilder ?

Answer 1

Defina sus creadores de acciones dentro de un rasgo con el servicio de autenticación como un campo abstracto. Luego mézclelos en sus controladores, en los que inyecta el servicio. Por ejemplo:

trait MyActionBuilders {
  // the abstract dependency
  def authService: AuthenticationService

  def AuthenticatedAction = new ActionBuilder[AuthenticatedRequest] {
    override def invokeBlock[A](request: Request[A], block(AuthenticatedRequest[A]) => Future[Result]): Future[Result] = {
      authService.authenticate(...)
      ...
    }
  }
}

y el controlador:

@Singleton
class MyController @Inject()(authService: AuthenticationService) extends Controller with MyActionBuilders {    
  def myAction(...) = AuthenticatedAction { implicit request =>
    Ok("authenticated!")
  }
}

Answer 2

Me gusta la respuesta aceptada, pero por alguna razón el compilador no reconocería la referencia authService. Resolví esto con bastante facilidad simplemente enviando el servicio en la firma del método, un ...

class Authentication @Inject()(authenticationService: AuthenticationService) extends Controller with ActionBuilders {

  def testAuth = AuthenticatedAction(authenticationService).async { implicit request =>
    Future.successful(Ok("Authenticated!"))
  }

}

Answer 3

No me gustó la forma en que se requería heredar en el ejemplo anterior. Pero aparentemente es posible simplemente envolver un object dentro de la clase:

class Authentication @Inject()(authService: AuthenticationService) {
  object AuthenticatedAction extends ActionBuilder[Request] {
    def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) = {
      // Do your thing wit the authService...
      block(request)
    }
  }
}

class YourController @Inject() (val auth: Authentication) extends Controller (
  def loggedInUser = auth.AuthenticatedAction(parse.json) { implicit request =>
    // ...
  }
}