AlamoFire异步完成JSON请求处理程序 [英] AlamoFire asynchronous completionHandler for JSON request

问题描述

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

Having used the AlamoFire framework I've noticed that the completionHandler is run on the main thread. Im wondering if the code below is a good practice for creating a Core Data import task within the completion handler:

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);

                    }
                });
            }

推荐答案

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

This is a really good question. Your approach is perfectly valid. However, Alamofire can actually help you streamline this even more.

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

In you example code, you are jumping between the following dispatch queues:

1. NSURLSession调度队列


2. TaskDelegate调度验证和序列化程序处理队列


3. 用于调用完成处理程序的主调度队列


4. 用于JSON处理的高优先级队列


5. 主调度队列以更新用户界面（如有必要）

1. NSURLSession dispatch queue
2. TaskDelegate dispatch queue for validation and serializer processing
3. Main dispatch queue for calling your completion handler
4. High priority queue for JSON handling
5. Main dispatch queue to update the user interface (if necessary)

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

As you can see, you're hopping all over the place. Let's take a look at an alternative approach leveraging a powerful feature inside Alamofire.

Alamofire在其自身的低级处理中内置了最佳方法。最终由所有自定义响应序列化程序调用的单个 response 方法支持自定义分派队列（如果您选择使用它）。

Alamofire has an optimal approach built into it's own low level processing. The single response method that ultimately gets called by all custom response serializers has support for a custom dispatch queue if you choose to use it.

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

While GCD is amazing at hopping between dispatch queues, you want to avoid jumping to a queue that is busy (e.g. the main thread). By eliminating the jump back to the main thread in the middle of the async processing, you can potentially speed things up considerably. The following example demonstrates how to do this using Alamofire logic straight out-of-the-box.

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）

Alamofire 3.x (Swift 2.2 and 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）

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 Dispatch Queue Breakdown

Alamofire Dispatch Queue Breakdown

Here is the breakdown of the different dispatch queues involved with this approach.

1. NSURLSession调度队列


2. TaskDelegate调度队列用于验证和序列化程序处理


3. 用于JSON处理的自定义管理器并发调度队列


4. 用于更新用户界面（如有必要）的主调度队列
>

1. NSURLSession dispatch queue
2. TaskDelegate dispatch queue for validation and serializer processing
3. Custom manager concurrent dispatch queue for JSON handling
4. Main dispatch queue to update the user interface (if necessary)

摘要

通过消除返回主调度队列的第一跳，您可以消除了潜在的瓶颈，并且使整个请求和处理变得异步。

Summary

By eliminating the first hop back to the main dispatch queue, you have eliminated a potential bottleneck as well as you have made your entire request and processing asynchronous. Awesome!

话虽如此，我不能太过强调熟悉Alamofire的内部原理是多么重要。您永远都不知道何时可以找到真正可以帮助您改进自己的代码的东西。

With that said, I can't stress enough how important it is to get familiar with the internals of how Alamofire really works. You never know when you may find something that can really help you improve your own code.

这篇关于AlamoFire异步完成JSON请求处理程序的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！