1

我开始学玩了

我一直在试图了解 Action 是如何实施的。我只是不明白语言结构，这真的让我很沮丧......

没看懂怎么写？

val echo = Action { request => Ok("得到请求 [" + request + "]") }

并让它编译....那是什么样的构造？这将是一个将函数作为参数的案例类，我可能有.....

但这里是动作的定义https://github.com/playframework/playframework/blob/master/framework/src/play/src/main/scala/play/api/mvc/Action.scala

这基本上说明 Action 是一个函数对象 Trait ，它可以通过从 Essential 操作中获取的应用以及它自己定义的应用来获取 requestHeader 或 Request ....

/**
 * An `EssentialAction` underlies every `Action`. Given a `RequestHeader`, an
 * `EssentialAction` consumes the request body (an `Array[Byte]`) and returns
 * a `Result`.
 *
 * An `EssentialAction` is a `Handler`, which means it is one of the objects
 * that Play uses to handle requests.
 */
trait EssentialAction extends (RequestHeader => Iteratee[Array[Byte], Result]) with Handler {

  /**
   * Returns itself, for better support in the routes file.
   *
   * @return itself
   */
  def apply() = this

}

/**
 * Helper for creating `EssentialAction`s.
 */
object EssentialAction {

  def apply(f: RequestHeader => Iteratee[Array[Byte], Result]): EssentialAction = new EssentialAction {
    def apply(rh: RequestHeader) = f(rh)
  }
}

/**
 * An action is essentially a (Request[A] => Result) function that
 * handles a request and generates a result to be sent to the client.
 *
 * For example,
 * {{{
 * val echo = Action { request =>
 *   Ok("Got request [" + request + "]")
 * }
 * }}}
 *
 * @tparam A the type of the request body
 */
trait Action[A] extends EssentialAction {

  /**
   * Type of the request body.
   */
  type BODY_CONTENT = A

  /**
   * Body parser associated with this action.
   *
   * @see BodyParser
   */
  def parser: BodyParser[A]

  /**
   * Invokes this action.
   *
   * @param request the incoming HTTP request
   * @return the result to be sent to the client
   */
  def apply(request: Request[A]): Future[Result]

  def apply(rh: RequestHeader): Iteratee[Array[Byte], Result] = parser(rh).mapM {
    case Left(r) =>
      Play.logger.trace("Got direct result from the BodyParser: " + r)
      Future.successful(r)
    case Right(a) =>
      val request = Request(rh, a)
      Play.logger.trace("Invoking action with request: " + request)
      Play.maybeApplication.map { app =>
        play.utils.Threads.withContextClassLoader(app.classloader) {
          apply(request)
        }
      }.getOrElse {
        apply(request)
      }
  }(executionContext)

我自己无法重现它，一个简单的案例它无法编译，这真是太奇怪了......

4

2 回答 2

2

你需要看的是它继承的Action 对象和这个apply方法。

于 2014-06-05T19:44:50.280 回答
1

在 scala 中，我们可以使用功能块调用 Action：

行动 { 请求 => ..... }

这被重写为：

Action.apply({ 请求 => ... })

您可能想知道隐式关键字在做什么。使函数的参数在函数内的隐式范围内可用是一种简写方式。换句话说：

动作应用 { 隐式请求 => ... }

是相同的：

动作应用 { request => 隐式 val _some_random_name_ = request ... }

从这里引用：https ://groups.google.com/forum/#!topic/scala-user/sR-FD3eiUcQ

于 2015-01-28T21:27:26.060 回答