Question

如果有人可以指出如何修改以下播放框架日志记录过滤器（参考play filters）以获得以下内容，我将不胜感激：

打印并修改传入的json请求正文和http标题（例如，用于POST，PUT和＆amp; PATCH）
打印并修改传出的json响应正文和http标题
修改示例可以是在请求和响应主体中注入/替换某些标记字符串，例如
请求Json：{＆＃39; a＆＃39;：＆＃39; REPLACE_ME＆＃39;＆＃39;＆＃39;：＆＃39; REPLACE_ME_TOO＆＃39;＆＃39; c＆＃39 ;：＆＃39;东西＆＃39;}
回应Json：{＆＃39; A＆＃39;：＆＃39; REPLACE_ME＆＃39;＆＃39; Bb＆＃39;：＆＃39; REPLACE_ME_TOO＆＃39;＆＃39; C＆＃39 ;：＆＃39;任何＆＃39;}

import play.api.Logger
import play.api.mvc._
import play.api.libs.concurrent.Execution.Implicits.defaultContext

object LoggingFilter extends EssentialFilter {
  def apply(nextFilter: EssentialAction) = new EssentialAction {
    def apply(requestHeader: RequestHeader) = {
      val startTime = System.currentTimeMillis
      nextFilter(requestHeader).map { result =>
        val endTime = System.currentTimeMillis
        val requestTime = endTime - startTime
        Logger.info(s"${requestHeader.method} ${requestHeader.uri}" +
          s" took ${requestTime}ms and returned ${result.header.status}")
        result.withHeaders("Request-Time" -> requestTime.toString)
      }
    }
  }
}

到目前为止，我已经尝试了以下解决方案，它显然是丑陋和残酷的，因为它包含阻塞调用和神秘操作符。我仍然不确定如何重新注入修改后的请求体。（所提出的解决方案包含来自2和3的代码。）

import play.api.libs.iteratee._
import play.api.mvc._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration

class ReqResFilter extends EssentialFilter {

  def apply(next: EssentialAction) = new EssentialAction {
    def apply(requestHeader: RequestHeader): Iteratee[Array[Byte], Result] = {
      modifyRequest(next, requestHeader).map { result => modifyResponse(result)}
    }
  }

  def bytesToString: Enumeratee[Array[Byte], String] = Enumeratee.map[Array[Byte]] { bytes => new String(bytes)}

  def modifyRequest(nextA: EssentialAction, request: RequestHeader): Iteratee[Array[Byte], Result] = {

    def step(body: Array[Byte], nextI: Iteratee[Array[Byte], Result])(i: Input[Array[Byte]]):
    Iteratee[Array[Byte], Result] = i match {
      case Input.EOF =>
        val requestBody = new String(body, "utf-8")
        val modRequestBody = requestBody.replaceAll("REPLACE_ME", "1224")
        println(s"modifyRequest:: Here is the request body ${modRequestBody}")
        Iteratee.flatten(nextI.feed(Input.EOF))
      case Input.Empty =>
        Cont[Array[Byte], Result](step(body, nextI) _)
      case Input.El(e) =>
        val curBody = Array.concat(body, e)
        Cont[Array[Byte], Result](step(curBody, Iteratee.flatten(nextI.feed(Input.El(e)))) _)
    }

    val nextIteratee: Iteratee[Array[Byte], Result] = nextA(request)

    Cont[Array[Byte], Result](i => step(Array(), nextIteratee)(i))
  }

  def modifyResponse(result: Result): Result = {
    val responseBodyFuture: Future[String] = result.body |>>> bytesToString &>> Iteratee.consume[String]()
    val responseBody = Await.result(responseBodyFuture, Duration.Inf)
    val modResponseBody = responseBody.replaceAll("REPLACE_ME", "1224")
    println(s"modifyResponse:: Here is the response body ${modResponseBody}")
    new Result(result.header, Enumerator(modResponseBody.getBytes)).withHeaders("New-Header" -> "1234")
  }
}

Answer 1

因为这里没有解决方案，所以让我添加一个解决方案。为了使它工作，我在modifyRequest（）中重写了step（），如下所示：

def step(body: Array[Byte], nextI: Iteratee[Array[Byte], Result])(i: Input[Array[Byte]]):
Iteratee[Array[Byte], Result] = i match {
  case Input.EOF =>
    val requestBody = new String(body, "utf-8")
    val modRequestBody = requestBody.replaceAll("REPLACE_ME", "1224")
    println(s"modifyRequest:: Here is the request body ${modRequestBody}")
    Iteratee.flatten(nextI.feed(Input.El(modRequestBody.getBytes)))
  case Input.Empty =>
    Cont[Array[Byte], Result](step(body, nextI) _)
  case Input.El(e) =>
    val curBody = Array.concat(body, e)
    Cont[Array[Byte], Result](step(curBody, nextI) _)
}

此更改仍在阻塞，因为它会缓冲传入的请求。如果有人有更好的解决方案，请发帖。感谢。

播放修改json请求和响应的框架过滤器

1 个答案: