为了您的需要，我不认为使用 onRouteRequest 会起作用（至少优雅）。
但是让我们尝试使用专用结构进行拦截。
以下是拦截请求、计算一些通用内容并将其传递给 Action 的方法
首先，这里有一个Interceptor 对象，它有一个方法intercept 和一个方便的方法username：
object Interceptor {
def intercept[A, B](f: RequestHeader => Option[B], e: RequestHeader => Result)(action: B => Action[A]): Action[(Action[A], A)] = {
val bodyParser = BodyParser {
request =>
f(request) map {
b =>
val innerAction = action(b)
innerAction.parser(request).mapDone {
body => body.right.map(innerBody => (innerAction, innerBody))
}
} getOrElse {
Done(Left(e(request)), Input.Empty)
}
}
Action(bodyParser) {
request =>
val (innerAction, innerBody) = request.body
innerAction(request.map(_ => innerBody))
}
}
def username[A](check: RequestHeader => Option[String]): ((String) => Action[A]) => Action[(Action[A], A)] = intercept(check, r => Results.Unauthorized("not logged in"))
}
如您所见，工作函数intercept 让您有机会根据请求内容计算一些内容。 B 类型的哪个计算结果可能会失败（Option），在这种情况下，有一个处理程序来告诉你该做什么。
定义了要计算的内容后，您可以使用一个函数定义您的 action，该函数接受 B 并给出 Action[A]。
username 方法只是一个简单的预定义拦截器，可以让我们定义如何检索登录的用户名，仅用于说明。
下面是我们如何在您的Controller 中使用它们的方法
//index is defined for both GET and POST in routes, but fails on POST
// thanks to the interceptor that checks at first the used method
// the case mustn't be handled in the Action definition
def index = Interceptor.intercept(
/*check the method*/
request => if (request.method == "GET") Some(request.method) else None,
/*not a GET => bad request*/
request => BadRequest(request.method + " not allowed")
) { /*the computation result*/method => Action {
Ok("The method : " + method)
}
}
//this controller retrieve the username in the session and renders it in a OK response
def secured = Interceptor.username(r => r.session.get("username")) { username => Action {
Ok("You're logged in as " + username)
}
}
//this enables you to logged in => store in session
def login(u:String) = Action { request => {
Ok("Logged in as " + u) withSession(("username" -> u))
}
}
现在，如果您有通用计算，则可以创建预配置的拦截器（这里我使用的是案例类，但只需定义一个部分应用 interceptor 的函数就足够了）
case class Intercept[B] (f: RequestHeader => Option[B], e: RequestHeader => Result) {
def apply[A](action: B => Action[A]) = Interceptor.intercept[A,B](f, e)(action)
}
val getInterceptor = Intercept[String](
request => if (request.method == "GET") Some(request.method) else None,
request => BadRequest(request.method + " not allowed")
)
def index2 = getInterceptor { method => Action {
Ok("Da method : " + method)
}
}
EDIT与评论相关：
根据您的评论，这是使用拦截器的方法（请注意，我已经模拟了主机检索和检查）
使用hosted 和anotherHosted，您将能够测试此工作流程：
- /hosted/false?host=myhost => 404 因为一开始 myhost 没有被缓存，我为检查过的模型提供了 false
- /hosted/true?host=myhost => 不在缓存中，但它会添加它，然后没有 404
- /hosted/anotherHosted/false?host=myhost => 在缓存中，因为它是托管的 => 没有 404
- /hosted/anotherHosted/false?host=notMyhost => 404
这里是代码
def getHost(request:RequestHeader) = request.queryString.get("host").get.head
def checkHost(host:String, b: Boolean) = b
val checkHosted = (b: Boolean) => Intercept[String](
request => {
val host = getHost(request)
Cache.getAs[String](host) match {
case x@Some(_) => x
case None => if (checkHost(host, b)) {
Cache.set(host, host)
Some(host)
} else None
}
},
request => NotFound(getHost(request) + "not hosted")
)
def hosted(b:String) = checkHosted(b.toBoolean) {
host => Action {
Ok("this host is ok : " + host)
}
}
def anotherHosted(b:String) = checkHosted(b.toBoolean) {
host => Action {
Ok("this host is ok : " + host)
}
}