AlamoFire异步完成JSON请求处理程序

80

使用AlamoFire框架后，我注意到，completionHandler在主线程上运行。我想知道下面的代码是否是在完成处理程序中创建Core Data导入任务的好习惯：

Alamofire.request(.GET, "http://myWebSite.com", parameters: parameters)
            .responseJSON(options: .MutableContainers) { (_, _, JSON, error) -> Void in
                dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), { () -> Void in
                    if let err = error{
                        println("Error:\(error)")
                        return;
                    }

                    if let jsonArray = JSON as? [NSArray]{                       
                        let importer = CDImporter(incomingArray: jsonArray entity: "Artist", map: artistEntityMap);

                    }
                });
            }
swift  alamofire 
— M00s3
source

Answers:

156

这是一个非常好的问题。您的方法是完全有效的。但是，Alamofire实际上可以帮助您进一步简化此流程。

您的示例代码调度队列明细

在示例代码中，您将在以下调度队列之间跳转：

  1. NSURLSession分派队列
  2. TaskDelegate调度队列，用于验证和序列化程序处理
  3. 主调度队列，用于调用完成处理程序
  4. 用于JSON处理的高优先级队列
  5. 主调度队列以更新用户界面（如有必要）

如您所见，您到处都是。让我们看看利用Alamofire内部强大功能的另一种方法。

Alamofire响应调度队列

Alamofire在其自身的低级处理中内置了一种最佳方法。response如果您选择使用该方法，则最终由所有自定义响应序列化程序调用的单个方法将支持自定义调度队列。

尽管GCD在调度队列之间跳转非常出色，但您要避免跳转到繁忙的队列（例如主线程）。通过消除异步处理过程中跳回主线程的方式，您可以大大加快处理速度。以下示例演示了如何直接使用Alamofire逻辑来执行此操作。

Alamofire 1.x

let queue = dispatch_queue_create("com.cnoon.manager-response-queue", DISPATCH_QUEUE_CONCURRENT)

let request = Alamofire.request(.GET, "http://httpbin.org/get", parameters: ["foo": "bar"])
request.response(
    queue: queue,
    serializer: Request.JSONResponseSerializer(options: .AllowFragments),
    completionHandler: { _, _, JSON, _ in

        // You are now running on the concurrent `queue` you created earlier.
        println("Parsing JSON on thread: \(NSThread.currentThread()) is main thread: \(NSThread.isMainThread())")

        // Validate your JSON response and convert into model objects if necessary
        println(JSON)

        // To update anything on the main thread, just jump back on like so.
        dispatch_async(dispatch_get_main_queue()) {
            println("Am I back on the main thread: \(NSThread.isMainThread())")
        }
    }
)

Alamofire 3.x（Swift 2.2和2.3）

let queue = dispatch_queue_create("com.cnoon.manager-response-queue", DISPATCH_QUEUE_CONCURRENT)

let request = Alamofire.request(.GET, "http://httpbin.org/get", parameters: ["foo": "bar"])
request.response(
    queue: queue,
    responseSerializer: Request.JSONResponseSerializer(options: .AllowFragments),
    completionHandler: { response in
        // You are now running on the concurrent `queue` you created earlier.
        print("Parsing JSON on thread: \(NSThread.currentThread()) is main thread: \(NSThread.isMainThread())")

        // Validate your JSON response and convert into model objects if necessary
        print(response.result.value)

        // To update anything on the main thread, just jump back on like so.
        dispatch_async(dispatch_get_main_queue()) {
            print("Am I back on the main thread: \(NSThread.isMainThread())")
        }
    }
)

Alamofire 4.x（Swift 3）

let queue = DispatchQueue(label: "com.cnoon.response-queue", qos: .utility, attributes: [.concurrent])

Alamofire.request("http://httpbin.org/get", parameters: ["foo": "bar"])
    .response(
        queue: queue,
        responseSerializer: DataRequest.jsonResponseSerializer(),
        completionHandler: { response in
            // You are now running on the concurrent `queue` you created earlier.
            print("Parsing JSON on thread: \(Thread.current) is main thread: \(Thread.isMainThread)")

            // Validate your JSON response and convert into model objects if necessary
            print(response.result.value)

            // To update anything on the main thread, just jump back on like so.
            DispatchQueue.main.async {
                print("Am I back on the main thread: \(Thread.isMainThread)")
            }
        }
    )

Alamofire派遣队列明细

这是此方法涉及的不同调度队列的细分。

  1. NSURLSession分派队列
  2. TaskDelegate调度队列，用于验证和序列化程序处理
  3. 用于JSON处理的自定义管理器并发调度队列
  4. 主调度队列以更新用户界面（如有必要）

概要

通过消除返回主调度队列的第一跳，您消除了潜在的瓶颈，并使整个请求和处理成为异步。太棒了！

话虽如此，我对强调Alamofire真正工作原理的内在知识有多么重要。您永远不知道什么时候可以找到真正可以帮助您改进自己的代码的东西。

— cnoon
source
3
感谢您的详尽解释，@ cnoon。看来response现在调用了该方法的第二个参数，responseSerializer而不是serializer（在Alamofire 3.0中）。那引起了一个Cannot call value of non-function type 'NSHTTPURLResponse?'错误，让我有些困惑。
— 海伦·马丁（
请上传更改，该代码不可用。Swift 2.1，XCode 7.1
— Beraliv
那么responseJSON呢？如何传递队列参数
— OMGPOP，2016年
@cnoon，如果您还为swift 3添加更新，可能会很好。
— Mike.R
现在也适用于Swift 3。辉煌
— dejavu89年
2

Swift 3.0小更新，Alamofire（4.0.1），编辑@cnoon答案：

let queue = DispatchQueue(label: "com.cnoon.manager-response-queue",
                          qos: .userInitiated,
                          attributes:.concurrent)
Alamofire?.request(SERVER_URL, method: .post,
parameters: ["foo": "bar"], 
encoding: JSONEncoding.default,//by default
headers: ["Content-Type":"application/json; charset=UTF-8"])
.validate(statusCode: 200..<300).//by default
responseJSON(queue: queue, options: .allowFragments, 
completionHandler: { (response:DataResponse<Any>) in

        switch(response.result) {
        case .success(_):
            break
        case .failure(_):
            print(response.result.error)
            if response.result.error?._code == NSURLErrorTimedOut{
                //TODO: Show Alert view on netwok connection.
            }
            break
        }
    })
— 迈克
source
1

只是补充@cnoon的完美答案，如果您喜欢我使用的ResponseObjectSerializable话，可以将此并发行为嵌入请求扩展本身：

extension Request {
    public func responseObject<T: ResponseObjectSerializable>(completionHandler: Response<T, NSError> -> Void) -> Self {
        let responseSerializer = ResponseSerializer<T, NSError> { request, response, data, error in
            guard error == nil else { return .Failure(error!) }

            let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
            let result = JSONResponseSerializer.serializeResponse(request, response, data, error)

            switch result {
            case .Success(let value):
                if let
                    response = response,
                    responseObject = T(response: response, representation: value)
                {
                    return .Success(responseObject)
                } else {
                    let failureReason = "JSON could not be serialized into response object: \(value)"
                    let error = Error.errorWithCode(.JSONSerializationFailed, failureReason: failureReason)
                    return .Failure(error)
                }
            case .Failure(let error):
                return .Failure(error)
            }
        }

        let queue = dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT)
        return response(queue: queue, responseSerializer: responseSerializer) { response in
            dispatch_async(dispatch_get_main_queue()) {
                completionHandler(response)
            }
        }
    }
}
— 拉斐尔·奥利维拉（Raphael Oliveira）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.