Alamofire返回SwiftyJSON结果的Swift扩展方法

Question

I migrated an app from Swift 2.2 to 3.0 which used an extension method from the Alamofire-SwiftyJSON project on GitHub. Alamofire-SwiftyJSON allows receiving the response from an Alamofire network request converted to a SwiftyJSON instance like this:

Alamofire.request(.GET, "http://httpbin.org/get", parameters: ["foo": "bar"])
    .responseSwiftyJSON({ (request, response, json, error) in
        print(json) // json is a SwiftyJSON 'JSON' instance
        print(error)
    })

The Alamofire-SwiftyJSON project was not updated for Swift 3 as of writing this question. I'm looking for an equivalent implementation of the responseSwiftyJSON extension method that works with Swift 3+ and Alamofire 4+.

Answer 1

Extension Methods

This solution incorporates a suggestion for working with Alamofire from the SwiftyJSON readme .

It is based on similar extensions included with Alamofire in ResponseSerialization.swift :

• DataRequest.responseJSON(queue:options:completionHandler:)
• DataRequest.jsonResponseSerializer(options:)

This solution works with Swift 3 and above. It was tested with Alamofire 4.2+ and SwiftyJSON 3.1.3+.

import Alamofire
import SwiftyJSON

extension DataRequest {

    /// Adds a handler to be called once the request has finished.
    ///
    /// - parameter options:           The JSON serialization reading options. Defaults to `.allowFragments`.
    /// - parameter completionHandler: A closure to be executed once the request has finished.
    ///
    /// - returns: The request.
    @discardableResult
    public func responseSwiftyJSON(
        queue: DispatchQueue? = nil,
        options: JSONSerialization.ReadingOptions = .allowFragments,
        completionHandler: @escaping (DataResponse<JSON>) -> Void) -> Self {
            return response(
                queue: queue,
                responseSerializer: DataRequest.swiftyJSONResponseSerializer(options: options),
                completionHandler: completionHandler
            )
    }

    /// Creates a response serializer that returns a SwiftyJSON instance result type constructed from the response data using
    /// `JSONSerialization` with the specified reading options.
    ///
    /// - parameter options: The JSON serialization reading options. Defaults to `.allowFragments`.
    ///
    /// - returns: A SwiftyJSON response serializer.
    public static func swiftyJSONResponseSerializer(
        options: JSONSerialization.ReadingOptions = .allowFragments) -> DataResponseSerializer<JSON> {
            return DataResponseSerializer { _, response, data, error in
                let result = Request.serializeResponseJSON(options: options, response: response, data: data, error: error)
                switch result {
                    case .success(let value):
                        return .success(JSON(value))
                    case .failure(let error):
                        return .failure(error)
                }
            }
    }
}

Example Use:

Alamofire.request("https://httpbin.org/get").validate().responseSwiftyJSON {
        response in

        print("Response: \(response)")

        switch response.result {
            case .success(let json):
                // Use SwiftyJSON instance
                print("JSON: \(json)")

            case .failure(let error):
                // Handle error
                print("Error: \(error)")
        }
    }