一、自定义action
从一个日志装饰器的例子开始
1.在invokeBlock方法中实现
import play.api.mvc._
class LoggingAction @Inject() (parser: BodyParsers.Default)(implicit ec: ExecutionContext) extends ActionBuilderImpl(parser) {
override def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) = {
Logger.info("Calling action")
block(request)
}
}
在控制器中使用依赖注入来得到一个实例
class MyController @Inject()(loggingAction: LoggingAction,cc:ControllerComponents)extends AbstractController(cc) {
def index = loggingAction {
Ok("Hello World")
}
}
ActionBuilder提供了所有构建action的方法，因此也适用于自定义的解析器
def submit = loggingAction(parse.text) { request =>
Ok("Got a body " + request.body.length + " bytes long")
}
2.编写Action
可重用的动作代码可以通过包装动作来实现
import play.api.mvc._
case class Logging[A](action: Action[A]) extends Action[A] {
def apply(request: Request[A]): Future[Result] = {
Logger.info("Calling action")
action(request)
}
override def parser = action.parser
override def executionContext = action.executionContext
}
我们也可以使用Action动作构建器来构建动作，而无需定义我们自己的动作类
import play.api.mvc._
def logging[A](action: Action[A])= Action.async(action.parser) { request =>
Logger.info("Calling action")
action(request)
}
也可以使用composeAction方法将操作混合到操作构建器中
class LoggingAction @Inject() (parser: BodyParsers.Default)(implicit ec: ExecutionContext) extends ActionBuilderImpl(parser) {
override def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) = {
block(request)
}
override def composeAction[A](action: Action[A]) = new Logging(action)
}
现在，建造者可以像以前一样使用
def index = loggingAction {Ok("Hello World")}
我们也可以在没有动作构建器的情况下混合包装动作
def index = Logging {
Action {
Ok("Hello World")
}
}
3.更复杂的actions
上面都是不影响请求的操作。当然，我们也可以读取和修改传入的请求对象，play支持X-Forwarded-For headers
import play.api.mvc._
import play.api.mvc.request.RemoteConnection
def xForwardedFor[A](action: Action[A]) = Action.async(action.parser) { request =>
val newRequest = request.headers.get("X-Forwarded-For") match {
case None => request
case Some(xff) =>
val xffConnection = RemoteConnection(xff, request.connection.secure, None)
request.withConnection(xffConnection)
}
action(newRequest)
}
阻断请求
import play.api.mvc._
import play.api.mvc.Results._
def onlyHttps[A](action: Action[A]) = Action.async(action.parser) { request =>
request.headers.get("X-Forwarded-Proto").collect {
case "https" => action(request)
} getOrElse {
Future.successful(Forbidden("Only HTTPS requests allowed"))
}
}
修改返回的结果
import play.api.mvc._
def addUaHeader[A](action: Action[A]) = Action.async(action.parser) { request =>
action(request).map(_.withHeaders("X-UA-Compatible" -> "Chrome=1"))
}
二、不同的请求类型
1.一些预先定义好的实现了ActionFunction的特质
ActionTransformer可以更改请求，例如增加额外的信息ActionFilter可以选择性的拦截请求，例如产生错误，不改变请求值ActionRefiner是上面两种情况的一般情况ActionBuilderi请求作为输入的特例，因此可以构建actions
2.认证
我们可以轻松实现我们自己的身份验证操作转换器，该转换器根据原始请求确定用户并将其添加到新的UserRequest。请注意，这也是一个ActionBuilder因为它使用一个简单Request作为输入
import play.api.mvc._
class UserRequest[A](val username: Option[String], request: Request[A]) extends WrappedRequest[A](request)
class UserAction @Inject()(val parser: BodyParsers.Default)(implicit val executionContext: ExecutionContext)
extends ActionBuilder[UserRequest, AnyContent] with ActionTransformer[Request, UserRequest] {
def transform[A](request: Request[A]) = Future.successful {
new UserRequest(request.session.get("username"), request)
}
}
Play还提供内置身份验证操作构建器。有关这方面的信息以及如何使用它可以在这里找到。内置的身份验证操作构建器只是一个简便的帮助工具，可以将简单情况下实现身份验证所需的代码最小化，其实现方式与上述示例非常相似。
如果内置的助手不合适，可以自己编写
3.向请求添加信息
现在让我们考虑一个适用于Item对象的REST API 。/item/:itemId下可能有许多路径，每个路径都要查找item。在这种情况下，把下面的逻辑放入一个action函数可能会很有用
首先，我们将创建一个请求对象，把Item添加到我们的UserRequest
import play.api.mvc._
class ItemRequest[A](val item: Item, request: UserRequest[A]) extends WrappedRequest[A](request) {
def username = request.username
}
现在我们将创建一个查询item的action,要么返回一个错误（Left）要么返回一个新的ItemRequest（Right）。请注意，这个action精炼是定义在在获取item的id的方法中的
def ItemAction(itemId: String)(implicit ec: ExecutionContext) = new ActionRefiner[UserRequest, ItemRequest] {
def executionContext = ec
def refine[A](input: UserRequest[A]) = Future.successful {
ItemDao.findById(itemId)
.map(new ItemRequest(_, input))
.toRight(NotFound)
}
}
4.验证请求
最后，我们可能需要一个action函数来验证请求是否应该继续。例如，也许我们想要检查UserAction中的用户是否有权限访问ItemAction中的item，如果没有就报错
def PermissionCheckAction(implicit ec: ExecutionContext) = new ActionFilter[ItemRequest] {
def executionContext = ec
def filter[A](input: ItemRequest[A]) = Future.successful {
if (!input.item.accessibleByUser(input.username))
Some(Forbidden)
else
None
}
}
5.现在我们可以将这些action函数连接在一起（从一个ActionBuilder开始），用andThen创建一个action
def tagItem(itemId: String, tag: String)(implicit ec: ExecutionContext) =(userAction andThen ItemAction(itemId) andThen PermissionCheckAction) { request =>
request.item.addTag(tag)
Ok("User " + request.username + " tagged " + request.item.id)
}
Play还提供了一个全局过滤器API，这对于全局交叉问题很有用。
三、语言、内容的设置
1.语言
你可以使用play.api.mvc.RequestHeader#acceptLanguages从Accept-Language header中检索到请求可接受的语言列表，并根据其质量值对它们进行排序。Play在play.api.mvc.Controller#lang方法中使用它，提供一个隐式play.api.i18n.Lang值给你的actions，因此它们会自动使用最好的语言（如果你的应用程序支持的话，否则使用应用程序的默认语言）
2.内容
类似地，该play.api.mvc.RequestHeader#acceptedTypes方法给出请求的可接受结果的MIME类型列表。它从Accept header中检索到它们，并根据它们的质量因子对它们进行排序。
实际上，Accept header并不包含MIME类型，除了媒体范围（一个接收所有文本结果的请求可能会设置text/*范围，*/*范围意味着可接收所有结果类型）。控制器提供更高级的render方法来帮助您处理媒体范围。例如下面的action定义
val list = Action { implicit request =>
val items = Item.findAll
render {
case Accepts.Html() => Ok(views.html.list(items))
case Accepts.Json() => Ok(Json.toJson(items))
}
}
Accepts.Html()和Accepts.Json()是提取器，测试给定的范围是否匹配text/html和application/json。为了确定优先权，该render方法把play.api.http.MediaRange的部分函数带到play.api.mvc.Result，并尝试将其应用到在请求中找到的每个范围。
如果你的函数没有可支持的范围，则返回NotAcceptable。
例如，如果客户端使用以下值作为Accept header发出请求，Accept：*/*;q=0.5,application/json意味着它接受任何结果类型但偏好JSON，上面的代码将返回JSON表示。另一种情况application/xml意味着它只接受XML，则上面的代码将返回NotAcceptable。
3.请求提取器
请参阅play.api.mvc.AcceptExtractors.Accepts对象的API文档，以获取render方法中开箱即用支持的MIME类型列表。你可以使用play.api.mvc.Accepting case类轻松地为给定的MIME类型创建自己的提取器，
例如下面的代码创建一个提取器来检查媒体范围是否匹配audio/mp3MIME类型：
val AcceptsMp3 = Accepting("audio/mp3")
render {
case AcceptsMp3() => ???
}
}
四、错误的处理
1.支持自定义错误处理
如果使用BuiltInComponents构造自己的应用程序，要覆盖该httpErrorHandler方法以返回你的自定义处理程序的实例。
如果使用运行时依赖注入（例如Guice），则可以在运行时动态加载错误处理程序。最简单的方法是在根包创建一个类ErrorHandler（实现了，例如：HttpErrorHandler）
import play.api.http.HttpErrorHandler
import play.api.mvc._
import play.api.mvc.Results._
import scala.concurrent._
import javax.inject.Singleton
@Singleton
class ErrorHandler extends HttpErrorHandler {
def onClientError(request: RequestHeader, statusCode: Int, message: String) = {
Future.successful(
Status(statusCode)("A client error occurred: " + message)
)
}
def onServerError(request: RequestHeader, exception: Throwable) = {
Future.successful(
InternalServerError("A server error occurred: " + exception.getMessage)
)
}
}
如果你不想将错误处理程序置于根包中，或者你想要为不同的环境配置不同的错误处理程序，你可以通过在application.conf中配置play.http.errorHandler来实现，例如：play.http.errorHandler = "com.example.ErrorHandler"
2.扩展默认的错误处理程序
Play的默认错误处理提供了许多有用的函数。例如，在开发模式下，当发生服务器错误时，Play将尝试在你的应用程序中找到并渲染导致该异常的代码片段，以便可以快速查看并识别问题。你可能希望在生产中提供自定义服务器错误，同时仍在开发中维护该功能。
为了促进这一点，Play提供了一种DefaultHttpErrorHandler可以覆盖的便捷方法，以便可以将自定义逻辑与Play现有的行为混合在一起。例如，要仅在生产环境中提供自定义服务器错误消息，而且保留开发错误消息，并且还想提供特定的禁止错误页面
import javax.inject._
import play.api.http.DefaultHttpErrorHandler
import play.api._
import play.api.mvc._
import play.api.mvc.Results._
import play.api.routing.Router
import scala.concurrent._
@Singleton
class ErrorHandler @Inject() (
env: Environment,
config: Configuration,
sourceMapper: OptionalSourceMapper,
router: Provider[Router]
) extends DefaultHttpErrorHandler(env, config, sourceMapper, router) {
override def onProdServerError(request: RequestHeader, exception: UsefulException) = {
Future.successful(
InternalServerError("A server error occurred: " + exception.getMessage)
)
}
override def onForbidden(request: RequestHeader, message: String) = {
Future.successful(
Forbidden("You're not allowed to access this resource.")
)
}
}
查看完整的API文档DefaultHttpErrorHandler以查看可用于覆盖的方法以及如何利用它们