API 请求队列的最佳实践

Question

Swift 创建 API 请求队列的最佳做法是什么？我的意思是，虽然在一个函数上调用了超过 1 个 API，但如何确保第一个 API 先得到任何响应然后第二个 API 被执行？

func test() {
    getAPI1()
    getAPI2()
}

func getAPI1() {
    Connector.sharedInstance().getAPI1({ (
        data: NSData?, response: NSURLResponse?, error: NSError?) -> Void in

    })
}

...

我正在考虑给出一个标志来指示还有其他 API 仍在等待响应，因此将要执行的第二个 API 将等到标志被更改以前称为API。但是，还有其他更好的选择吗？谢谢

Answer 1

正如@Paulw11 所说，dispatch_groups 将适用于您的情况

dispatch_group_t myGroup = dispatch_group_create();

dispatch_group_enter(myGroup);
[asyncMethodWithCompletion:^(id *results, NSError* error){
    // process results
    dispatch_group_leave(myGroup);
}];

dispatch_group_notify(myGroup, dispatch_get_main_queue(),^{
    // This will be called when asyncMethodWithCompletion is completed
});

Answer 2

几乎每个 Cocoa API 都是异步工作的，例如

创建具有通用 Success 类型的枚举

enum Result<T> : ErrorType {
  case Success(T)
  case Failure(NSError)
}

getAPI1 returns 一个 NSData 对象成功否则 NSError

func getAPI1(completion:Result<NSData> -> ()) {
  var data : NSData?
  //
  if data != nil {
    completion(.Success(data!))
  } else {
    let error = NSError(domain: "my.domain", code: 9999, userInfo: [:])
    completion(.Failure(error))
  }
}

getAPI2 有一个 NSData 参数和 returns 一个字典 [String:AnyObject] 对象成功否则 NSError

func getAPI2(data:NSData, completion:Result<[String:AnyObject]> -> ()) {
  //
  completion(.Success([String:AnyObject]()))
}

test 根据结果异步执行这两个方法

func test() {
  getAPI1 { (result1) in
    switch result1 {
    case .Success(let data) :
      getAPI2(data) { (result2) in
        switch result2 {
        case .Success(let dictionary) :
          dispatch_async(dispatch_get_main_queue()) {
            // update UI with the dictionary
          }
        case .Failure(let error) : print(error)
        }
      }

    case .Failure(let error) : print(error)
    }
  }
}

API 请求队列的最佳实践

Best practice for API Request's Queue

api

optimistic-locking

ios

swift