我使用的 API 需要多次请求才能获得搜索结果。之所以这样设计，是因为搜索可能需要很长时间(> 5 分钟)。初始响应会立即返回有关搜索的元数据，并且该元数据将用于后续请求，直到搜索完成。我不控制 API。

• 第一个请求是对 https://api.com/sessions/search/ 的 POST
• 对此请求的响应包含有关搜索的 cookie 和元数据。此响应中的重要字段是 search_cookie(一个字符串)和 search_completed_pct(一个 Int)
• 第二个请求是一个 POST 到 https://api.com/sessions/results/将 search_cookie 附加到 URL。例如https://api.com/sessions/results/c601eeb7872b7+0
• 对第二个请求的响应将包含:
  • 查询完成后的搜索结果(又名 search_completed_pct == 100)
  • 有关搜索进度的元数据，search_completed_pct 是搜索进度，介于 0 和 100 之间。
• 如果搜索未完成，我想每 5 秒发出一次请求，直到完成(又名 search_completed_pct == 100)

我在这里发现了很多类似的帖子，很多都使用 Dispatch Groups 和 for 循环，但这种方法对我不起作用。我尝试了一个 while 循环并遇到了变量范围问题。调度组也不适合我。这闻起来像是走错了路，但我不确定。

我正在寻找合适的设计来进行这些递归调用。我应该使用委托(delegate)还是闭包+循环？我遇到了困难，需要一些帮助。

下面的代码是我尝试过的大致思路(为清晰起见进行了编辑。没有 dispatch_groups()、错误处理、json 解析等)

Viewcontroller.swift

apiObj.sessionSearch(domain) { result in
  Log.info!.message("result: \(result)")
})

ApiObj.swift

func sessionSearch(domain: String, sessionCompletion: (result: SearchResult) -> ()) {

      // Make request to /search/ url
      let task = session.dataTaskWithRequest(request) { data, response, error in 
        let searchCookie = parseCookieFromResponse(data!)

       *********  pseudo code  **************
        var progress: Int = 0
        var results = SearchResults()

        while (progress != 100) {

          // Make requests to /results/ until search is complete  
          self.getResults(searchCookie) { searchResults in 
                progress = searchResults.search_pct_complete
            if (searchResults == 100) {
             completion(searchResults)
            } else {
              sleep(5 seconds)
            } //if
          } //self.getResults()
        } //while
     *********  pseudo code  ************
    } //session.dataTaskWithRequest(
 task.resume()
 }


func getResults(cookie: String, completion: (searchResults: NSDictionary) -> ()) 

      let request = buildRequest((domain), url: NSURL(string: ResultsUrl)!)
      let session = NSURLSession.sharedSession()
      let task = session.dataTaskWithRequest(request) { data, response, error in 
        let theResults = getJSONFromData(data!)
        completion(theResults)
     }
  task.resume()
  }

最佳答案

好吧，首先，似乎很奇怪没有带有 GET 请求的 API 只返回结果——即使这可能需要几分钟。但是，正如您提到的，您无法更改 API。

因此，根据您的描述，我们需要发出一个有效地“轮询”服务器的请求。我们这样做，直到我们检索到 已完成 的 Search 对象。

因此，一种可行的方法是有意定义以下函数和类:

从服务器返回的“搜索”对象的协议(protocol):

public protocol SearchType {
    var searchID: String { get }
    var isCompleted: Bool { get }
    var progress: Double { get }
    var result: AnyObject? { get }
}

在客户端使用具体的结构或类。

向服务器发出请求以创建搜索对象的异步函数(您的#1 POST 请求):

func createSearch(completion: (SearchType?, ErrorType?) -> () )

然后是另一个异步函数，它获取一个“Search”对象，如果完成则可能获取结果:

func fetchSearch(searchID: String, completion: (SearchType?, ErrorType?) -> () )

现在，一个异步函数获取某个“searchID”(您的“search_cookie”)的结果 - 并在内部实现轮询:

func fetchResult(searchID: String, completion: (AnyObject?, ErrorType?) -> () )

fetchResult 的实现现在可能如下所示:

func fetchResult(searchID: String, 
    completion: (AnyObject?, ErrorType?) -> () ) {
    func poll() {
        fetchSearch(searchID) { (search, error) in
            if let search = search {
                if search.isCompleted {
                    completion(search.result!, nil)
                } else {
                    delay(1.0, f: poll)
                }
            } else {
                completion(nil, error)
            }
        }
    }
    poll()
}

此方法使用本地函数 poll 来实现轮询功能。 poll 调用 fetchSearch 并在完成时检查搜索是否完成。如果不是，它会延迟一定的持续时间，然后再次调用 poll。这看起来像一个递归调用，但实际上它不是，因为再次调用时 poll 已经完成。本地函数似乎适合这种方法。

函数 delay 只是等待指定的秒数，然后调用提供的闭包。 delay 可以根据 dispatch_after 或带有可取消调度计时器的方式轻松实现(我们需要稍后实现取消)。

我没有展示如何实现 createSearch 和 fetchSearch。这些可以使用第三方网络库轻松实现，也可以基于 NSURLSession 轻松实现。

结论:

可能会变得有点麻烦的是实现错误处理和取消，以及处理所有的完成处理程序。为了以简洁优雅的方式解决这个问题，我建议使用一个实现“Promises”或“Futures”的辅助库——或者尝试用 Rx 解决它。

例如利用“类 Scala” future 的可行实现:

func fetchResult(searchID: String) -> Future<AnyObject> {
    let promise = Promise<AnyObject>()
    func poll() {
        fetchSearch(searchID).map { search in
            if search.isCompleted {
                promise.fulfill(search.result!)
            } else {
                delay(1.0, f: poll)
            }
        }
    }
    poll()
    return promise.future!
}

您将开始获得如下所示的结果:

createSearch().flatMap { search in
    fetchResult(search.searchID).map { result in
        print(result)
    }
}.onFailure { error in
    print("Error: \(error)")
}

以上内容包含完整的错误处理。它还不包含取消。您确实需要实现一种取消请求的方法，否则轮询可能不会停止。

使用“CancellationToken”实现取消的解决方案可能如下所示:

func fetchResult(searchID: String, 
    cancellationToken ct: CancellationToken) -> Future<AnyObject> {
    let promise = Promise<AnyObject>()
    func poll() {
        fetchSearch(searchID, cancellationToken: ct).map { search in
            if search.isCompleted {
                promise.fulfill(search.result!)
            } else {
                delay(1.0, cancellationToken: ct) { ct in
                    if ct.isCancelled {
                        promise.reject(CancellationError.Cancelled)
                    } else {
                        poll()
                    }
                }
            }
        }
    }
    poll()
    return promise.future!
}

它可能被称为:

let cr = CancellationRequest()
let ct = cr.token
createSearch(cancellationToken: ct).flatMap { search in
    fetchResult(search.searchID, cancellationToken: ct).map { result in
        // if we reach here, we got a result
        print(result)
    }
}.onFailure { error in
    print("Error: \(error)")
}

稍后您可以取消请求，如下所示:

cr.cancel()

关于swift - 递归/循环 NSURLSession 异步完成处理程序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35327077/