Play 2.0 中文资料 - Action, Controller 和 Result | 隔叶黄莺 Yanbin Blog

2012-10-07 | 阅读(2,569)

什么是 Action?

多数的请求被 Play 应用接收到，并由 Action 进行处理.

一个 play.api.mvc.Action 简单说来就是一个 (play.api.mvc.Request => play.api.mvc.Result) 函数，它处理请求并产生一个 result 发送给客户端.

val echo = Action { request =>
  Ok("Got request [" + request + "]")
}

val echo = Action { request =>

Ok("Got request [" + request + "]")

}

Action 返回一个 play.api.mvc.Result 值, 代表着发送给 Web 客户端的 HTTP 响应. 上面的例子中 Ok 构造了一个 200 OK 的响应，它包含了 text/plain 类型的响应体.

建造一个 Action

play.api.mvc.Action 伴生对象提供有多个帮助方法用于构建 Action 值.

最简单的一个方法是以返回值为 Result 的表达式块作为参数:

Action {
  Ok("Hello world")
}

Action {

Ok("Hello world")

}

这是创建 Action 的最简单的方式, 但是我们无法得到传入的请求的引用. 通常调用 Action 的时候会要求访问 HTTP 请求.

因此，还有另外一个 Action 建造器，它接收一个函数 Request => Result 作为参数:

Action { request =>
  Ok("Got request [" + request + "]")
}

Action { request =>

Ok("Got request [" + request + "]")

}

经常会用 implicit 来标记 request 参数，这样可在其他的 API 需要的时候隐式的使用它:

Action { implicit request =>
  Ok("Got request [" + request + "]")
}

Action { implicit request =>

Ok("Got request [" + request + "]")

}

最后一种创建 Action 值的方式是指定一个附加的 BodyParser 作为参数:

Action(parse.json) { implicit request =>
  Ok("Got request [" + request + "]")
}

Action(parse.json) { implicit request =>

Ok("Got request [" + request + "]")

}

Body 解析器将会在本手册的后面讲到. 当前你仅需了解其他创建 Action 值的方法是使用了一个默认的任意内容请求数据体解析器 (Any content body parser).

Controller 是 action 的产生器

Controller 总是一个用来产生 Action 值的单例对象.

最简单的用于定义一个 Action 产生器的案例就是一个无参并返回 Action 值的方法:

package controllers

import play.api.mvc._

object Application extends Controller {

  def index = Action {
    Ok("It works!")
  }

}

package controllers

import play.api.mvc._

object Application extends Controller {

def index = Action {

Ok("It works!")

}

当然了, Action 产生器方法也可以带参数, 这些参数能够被 Action 闭包捕获的到:

def hello(name: String) = Action {
  Ok("Hello " + name)
}

def hello(name: String) = Action {

Ok("Hello " + name)

}

Unmi 注: 从 Action 开始要理解下 Scala 比较灵活的语法了。首先感性的知道下 Scala 方法定义的最主要四种形式是，不妨先记下它们来：

def index = Action { ...... }   //不访问 request
def index = Action { request => ...... }  //代码块中要访问 request
def index = Action(parse.json) { ...... } //这是调用了柯里化(currying) 后的函数
def index(name: String) = Action { ...... } //获得请求参数 name

def index = Action { ...... } //不访问 request

def index = Action { request => ...... } //代码块中要访问 request

def index = Action(parse.json) { ...... } //这是调用了柯里化(currying) 后的函数

def index(name: String) = Action { ...... } //获得请求参数 name

拿第二行来说明它的由来，它的完整的方法定义如下：

def index = {
  Action( request =>
    ......
  )
}

def index = {

Action( request =>

......

)

}

Unmi 注: Scala 把上面的写法转换成 def index Action { request => .......} 是基于以下几个规则的：

1. 如果定义的方法返回值不是 Unit 类型的话就必须要在方法实现之前加上等号

2. 如果方法实现只有一条语句，或者 Scala 能够推断出方法何时结束，则可以省略掉方法体外围的大括号，此处的 index 就是直接返回 Action 方法的值

3. 如果方法只有一个参数，则调用它时可以用花括号代替小括号包围参数，所以通常把 Action( request => ......) 写成了 Action{ request => ......}。这样写的好处就是它看起来像是一种内建控制结构。这里 request => ...... 是一个闭包，或称字面函数参数

4. 在 Action.scala 源文件中，Action 是一个单例对象：

/**
 * Helper object to create `Action` values.
 */
object Action extends ActionBuilder

/**

* Helper object to create `Action` values.

object Action extends ActionBuilder

直接在对象后加上括号的写法会转去调用它相应的 apply 方法，上面的 Action 继承了特质 ActionBuilder，而在特质 ActionBuilder 中定义了如下几个 apply 方法：

/**
 * Provides helpers for creating `Action` values.
 */
trait ActionBuilder {

  /**
   * Constructs an `Action`.
   *
   * For example:
   * {{{
   * val echo = Action(parse.anyContent) { request =>
   *   Ok("Got request [" + request + "]")
   * }
   * }}}
   *
   * @tparam A the type of the request body
   * @param bodyParser the `BodyParser` to use to parse the request body
   * @param block the action code
   * @return an action
   */
  def apply[A](bodyParser: BodyParser[A])(block: Request[A] => Result): Action[A] = new Action[A] {
    def parser = bodyParser
    def apply(ctx: Request[A]) = block(ctx)
  }

  /**
   * Constructs an `Action` with default content.
   *
   * For example:
   * {{{
   * val echo = Action { request =>
   *   Ok("Got request [" + request + "]")
   * }
   * }}}
   *
   * @param block the action code
   * @return an action
   */
  def apply(block: Request[AnyContent] => Result): Action[AnyContent] = apply(BodyParsers.parse.anyContent)(block)

  /**
   * Constructs an `Action` with default content, and no request parameter.
   *
   * For example:
   * {{{
   * val hello = Action {
   *   Ok("Hello!")
   * }
   * }}}
   *
   * @param block the action code
   * @return an action
   */
  def apply(block: => Result): Action[AnyContent] = apply(_ => block)

}

/**

* Provides helpers for creating `Action` values.

trait ActionBuilder {

/**

* Constructs an `Action`.

* For example:

* {{{

* val echo = Action(parse.anyContent) { request =>

* Ok("Got request [" + request + "]")

* }

* }}}

* @tparam A the type of the request body

* @param bodyParser the `BodyParser` to use to parse the request body

* @param block the action code

* @return an action

def apply[A](bodyParser: BodyParser[A])(block: Request[A] => Result): Action[A] = new Action[A] {

def parser = bodyParser

def apply(ctx: Request[A]) = block(ctx)

}

/**

* Constructs an `Action` with default content.

* For example:

* {{{

* val echo = Action { request =>

* Ok("Got request [" + request + "]")

* }

* }}}

* @param block the action code

* @return an action

def apply(block: Request[AnyContent] => Result): Action[AnyContent] = apply(BodyParsers.parse.anyContent)(block)

/**

* Constructs an `Action` with default content, and no request parameter.

* For example:

* {{{

* val hello = Action {

* Ok("Hello!")

* }

* }}}

* @param block the action code

* @return an action

def apply(block: => Result): Action[AnyContent] = apply(_ => block)

}

从这些源文件知道 Action 里是个闭包就行，返回是个 Result 类型。至于执行时 request 值是怎么产生的还需研究下。

简单的 Result

目前我们只讲述简单的 Result: 一个具有状态代码的 HTTP Result, 一系列 HTTP 头和要发送到 Web 客户端的响应体.

这些 Result 由 play.api.mvc.SimpleResult 定义:

def index = Action {
  SimpleResult(
    header = ResponseHeader(200, Map(CONTENT_TYPE -> "text/plain")), 
    body = Enumerator("Hello world!")
  )
}

def index = Action {

SimpleResult(

header = ResponseHeader(200, Map(CONTENT_TYPE -> "text/plain")),

body = Enumerator("Hello world!")

)

}

当然，也有数个帮助方法让你创建通用的 Result，像下面例子中的 Ok Result:

def index = Action {
  Ok("Hello world!")
}

def index = Action {

Ok("Hello world!")

}

这会产生与之上例中完全相同的 Result.

下面是几个创建种种 Result 的例子:

val ok = Ok("Hello world!")
val notFound = NotFound
val pageNotFound = NotFound(<h1>Page not found</h1>)
val badRequest = BadRequest(views.html.form(formWithErrors))
val oops = InternalServerError("Oops")
val anyStatus = Status(488)("Strange response type")

val ok = Ok("Hello world!")

val notFound = NotFound

val pageNotFound = NotFound(<h1>Page not found</h1>)

val badRequest = BadRequest(views.html.form(formWithErrors))

val oops = InternalServerError("Oops")

val anyStatus = Status(488)("Strange response type")

所有的这些帮助方法可在 play.api.mvc.Results 特质和伴生对象中找到.

重定向也是简单的 Result

重定向浏览器到一个新的 URL 是另一类简单的 Result. 然而, 这类 Result 类型不会带上响应体.

下面是些创建重定向 Result 的几个帮助方法:

def index = Action {
  Redirect("/user/home")
}

def index = Action {

Redirect("/user/home")

}

默认是利用 303 SEE_OTHER 响应类型, 但是你可以根据需要设置特别的状态码:

def index = Action {
  Redirect("/user/home", status = MOVED_PERMANENTLY)
}

def index = Action {

Redirect("/user/home", status = MOVED_PERMANENTLY)

}

Unmi 注: 返回 Result 类型的各方法定义在 Controller 所继承的 Results(.scala) 文件中，如 Ok，Redirect 等方法。

“TODO” 虚页面

你可以用一个定义为 TODO 的空的 Action 实现: 这个 Result 是一个标准的 ‘Not implemented yet’ 结果页:

def index(name:String) = TODO

1	def index(name:String) = TODO

Unmi 注: TODO 定义在 trait Controller(.scala) 中:

  val TODO = Action {
    NotImplemented[play.api.templates.Html](views.html.defaultpages.todo())
  }

val TODO = Action {

NotImplemented[play.api.templates.Html](views.html.defaultpages.todo())

}

本文链接 https://yanbin.blog/play2-0-tutorials-cn-action-controller-result/, 来自隔叶黄莺 Yanbin Blog

2 Comments

Inline Feedbacks

View all comments

赖顺

9 years ago

很不错！正在学习

Play 2.0 中文资料–翻译附注解(持续更新中) | EvilCode 邪恶代码

12 years ago

[...] Play 2.0 中文资料 – Action, Controller 和 Result [...]

seetimee on 体验 Python FastAPI 的并发能力及线, 进程模型感谢
Yanbin on Mockito 3.4.0 开始可 Mock 静态方法有一个补救，新写了一篇 https://yanbin.blog/mockito-mock-static-method-in-multiple...
Yanbin on 升级到 Spring Boot 3 后 javax.inject.Named 不可用怎么，被抄袭了！算是被机器翻译引用的？
oleksi on 升级到 Spring Boot 3 后 javax.inject.Named 不可用https://www.springcloud.io/post/2023-02/springboot-3-javax-inject-name...
Zhe on 体验 Python FastAPI 的并发能力及线, 进程模型你在trio下得用 trio.sleep()，调用asyncio.sleep() 就会报错。

M	T	W	T	F	S	S
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30