基于请求参数的Scala Play运行时注入

Question

我正在使用Scala Play 2.6，并尝试使用依赖注入来实例化基于请求参数的服务类。如下面的示例代码所示，控制器类从查询字符串中获取支付方法

package controllers

import com.google.inject.Inject
import play.api.mvc._
import scala.concurrent.ExecutionContext

class PaymentController @Inject()()
                                 (implicit ec: ExecutionContext)
  extends InjectedController  {

  def doPayment() = Action.async { implicit request =>
    request.getQueryString("payment-method").getOrElse("") match {
      case "paypal" => // Inject a PaypalPaymentService
        val paymentService = Play.current.injector.instanceOf[PaypalPaymentService]
        paymentService.processPayment()

      case "creditcard" => // Inject a CreditCardPaymentService
        val paymentService = Play.current.injector.instanceOf[CreditCardPaymentService]
        paymentService.processPayment()

      case _ => // Return error
    }
  }
}

以及处理PayPal或信用卡付款的服务类

package services

import scala.concurrent.Future

trait PaymentService {    
  def processPayment(): Future[Boolean]    
}

package services

import com.google.inject.Inject
import scala.concurrent.{ExecutionContext, Future}
import play.api.libs.ws.WSClient

class PaypalPaymentService @Inject()(ws: WSClient)
                                     (implicit ec: ExecutionContext)
  extends PaymentService {

  def processPayment(): Future[Boolean] = {
    //Process paypal payment
  }
}

class CreditCardPaymentService @Inject()(ws: WSClient)
                                    (implicit ec: ExecutionContext)
  extends PaymentService {

  def processPayment(): Future[Boolean] = {
    //Process credit card payment

  }
}

对于Play 2.5以后的版本，＜code＞Play。当前和播放。应用程序已被弃用。

我有两个问题：

1. 上面的示例代码是基于请求参数注入类的正确方法吗？还是有其他更好的方法？
2. 对于Play 2.5/2.6，获得应用注射器的方式是什么？

Answer 1

您已经正确地说明了Play.current和Play.application已经被弃用，从2.5开始，使用它们的方式确实是通过注入它们。

我将更改您的控制器定义，以便您使用DI来包括所需的组件。类似于：

class PaymentController @Inject()(configuration: Configuration)
                                 (implicit ec: ExecutionContext) extends Controller  {


  // your code goes here
}

现在是棘手的部分。您可能会认为可以只注入应用程序：播放。应用程序，但这并不完全正确，因为您将遇到循环依赖项。这是正常的，因为您希望在实际进入应用程序时注入整个应用程序。有一个黑客，它是通过注入提供者[应用程序]。我称之为黑客，因为通常您不需要/不想注入整个应用程序。在 99% 的情况下，您只对特定部分感兴趣 - 例如配置、环境等。

解决方案来了。您只需注射注射器

class PaymentController @Inject()(injector: Injector)
                                 (implicit ec: ExecutionContext) extends Controller  {

  // your code goes here
}

从这里看，这场比赛很容易。只需使用Injector即可获得所需的服务。这样地：

case "paypal" => // Inject a PaypalPaymentService
      val paymentService = injector.instanceOf(classOf[PaypalPaymentService])
      paymentService.processPayment()

最后一句话是关于“正确的使用方法”。我实际上觉得你的方法还可以，不一定会改变。这个方向上的一个想法是，您创建一个模块，如下所示：

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

class PaymentModule extends AbstractModule {
  def configure() = {

    bind(classOf[PaymentService])
      .annotatedWith(Names.named("paypal"))
      .to(classOf[PaypalPaymentService])

    bind(classOf[PaymentService])
      .annotatedWith(Names.named("creditcard"))
      .to(classOf[CreditCardPaymentService])
  }
}

在这种情况下，拥有一个共同的特性（正如你所做的那样）会有所帮助，你可以有多个实现，甚至可以为你的测试模拟实现。如果模块位于根包中，则将自动注册该模块。否则，你应该告诉Play它的位置：

play.modules.enabled="模块.支付模块"