WSRequest重试次数

Question

下面是我的方法：

def buildWSRequest(url: String, accessToken: String, wsClient: WSClient) 
    : (WSRequest, WSResponse) = { 
    import AppImplicits._ 
    val d1 = new java.util.Date() 
    val request: WSRequest = wsClient.url(url) 
     .withHeaders("Authorization" -> ("Bearer " + accessToken)) 
     .withHeaders("Content-type" -> "application/json", "Accept" -> "application/json; charset=utf-8") 


    var response: WSResponse = null 
    try { 
     val future = request.get() 

     response = scala.concurrent.Await.result(future, duration) 

    } catch { 
     case ex: Throwable => throw ex.getCause 
    } 
    return (request, response) 
    } 

而我打电话的部分是：

var response: WSResponse = buildWSRequest("www.sampletest123.com", params.apply("accessToken").asInstanceOf[String], sslClient)._2 

我想再试wsRequest，n次，该怎么做？

Answer 1

未来重试n次UTIL未来成功

def retry[T](future: => Future[T])(retries: Int)(implicit ec: ExecutionContext): Future[T] = { 
    val promise = Promise[T]() 
    try { 
     val f = future 
     f onSuccess { case result => promise trySuccess result} 
     f onFailure { case th => 
     if (retries > 0) promise tryFailure th 
     else retry(future)(retries - 1) 
     } 
    } catch { 
     case th: Throwable => promise tryFailure th 
    } 
    promise.future 
    } 

retry需要将来的代码块由名称参数调用，然后运行未来。未来的计算会重试n次直到成功。

首先承诺是创造，并且未来返回给用户。然后，承诺的完成取决于给予未来的用户。如果使用给定的将来是成功的，那么它将立即返回，如果没有重试直到重试计数耗尽。最终，承诺完全取决于成功还是失败，取决于剩余的重试次数以及未来是否成功。另外需要注意的一点是，未来的计算可能会失败。所以使用try catch块来处理失败。

重试方法通常可用于任何未来。

进行这些更改现有的代码才能利用重试方法

def buildWSRequest(url: String, accessToken: String, wsClient: WSClient): Future[WSReponse] = { 
    wsClient.url(url) 
     .withHeaders("Authorization" -> ("Bearer " + accessToken)) 
     .withHeaders("Content-type" -> "application/json", "Accept" -> "application/json; charset=utf-8") 
     .get 
    } 

使用

val requestFuture: Future[WSRequest] = buildWSRequest(....) 
retry(requestFuture)(5) 

尼斯API使用隐式类语法

implicit class FutureUtils[T](future: => Future[T]) { 
    def retry(retries: Int): Future[T] = { 
     val promise = Promise[T]() 
     try { 
     val f = future 
     f onSuccess { case result => promise trySuccess result } 
     f onFailure { case th => 
      if (retries > 0) promise tryFailure th 
      else retry(retries - 1) 
     } 
     } catch { 
     case th: Throwable => promise tryFailure th 
     } 
     promise.future 
    } 
    } 

使用隐式类，您现在可以使用重试函数，就好像它在Future类/接口中声明的那样，而不是将未来代码块作为函数参数传递。

Future(doSomething).retry(10) 

一般建议

不要挡住

使用返回类型沟通，外界