Alamofire + HandyJSON 封装

• HandyJSON

HandyJSON 是一个用于 Swift 语言中的 JSON 序列化/反序列化库。

与其他流行的 Swift JSON 库相比，HandyJSON 的特点是，它支持纯 Swift 类，使用也简单。它反序列化时（把 JSON 转换为 Model ）不要求 Model 从 NSObject 继承(因为它不是基于KVC机制)，也不要求你为 Model 定义一个 Mapping 函数。只要你定义好 Model 类，声明它服从 HandyJSON 协议，HandyJSON 就能自行以各个属性的属性名为 Key，从 JSON 串中解析值。

• Alamofire

Alamofire 是 Swift 语言的 HTTP 网络库，相当于 Swift 实现 AFNetworking 版本。Alamofire 取名来源于 Alamo Fire flower。

• Alamofire 基本使用

 // 获取结果为 String
Alamofire.request(urlString).validate()
    . responseString { (response) in
        guard response.result.isSuccess else { return }
        guard let stringValue = response.result.value else { return }
        print("stringValue: \(stringValue)")
}

// 获取结果为 Json
Alamofire.request(urlString).validate()
    . responseJson { (response) in
        guard response.result.isSuccess else { return }
        guard let jsonValue = response.result.value else { return }
        print("jsonValue: \(jsonValue)")
}

Alamofire还提供了许多其他类型的响应处理方法：

response()
responseData()
responseString(encoding: NSStringEncoding)
responseJSON(options: NSJSONReadingOptions)
responsePropertyList(options: NSPropertyListReadOptions)

但是并没有方法可以直接给我们 Model

• Alamofire 结合 HandyJSON

使用 HandyJSON 我们可以将请求结果直接转换为 Model：

Alamofire.request(urlString).validate()
    . responseString { (response) in
        guard response.result.isSuccess else { return }
        guard let value = response.result.value else { return }
        if let model = JSONDeserializer<Model>.deserializeFrom(json: value) {
                print("get model: \(model)")
        }
}

虽然完成了功能，但是，我们希望可以像 responseString， responseJson 那样的方式来获取 Model

这就需要我们扩展 Alamofire 了，我们可以扩展一个 responseHandyJsonModel 方法：

import Alamofire
import HandyJSON

extension AFError {
    enum HandyJsonError: Swift.Error {
        case parseModelError(String)
    }
}

extension DataRequest {
    @discardableResult
    public func responseHandyJsonModel<T: HandyJSON>(
        type: T.Type,
        queue: DispatchQueue? = nil,
        completionHandler: @escaping (DataResponse<T>) -> Void)
        -> Self
    {
        return response(
            queue: queue,
            responseSerializer: DataRequest.handyJsonModelResponseSerializer(type: type),
            completionHandler: completionHandler
        )
    }
    
    public static func handyJsonModelResponseSerializer<T: HandyJSON>(type: T.Type) -> DataResponseSerializer<T> {
        return DataResponseSerializer { _, response, data, error in
            return Request.serializeResponseHandyJsonModel(type: type, response: response, data: data, error: error)
        }
    }
}

extension Alamofire.Request {
    public static func serializeResponseHandyJsonModel<T: HandyJSON>(
        type: T.Type,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?)
        -> Result<T>
    {
        guard error == nil else { return .failure(error!) }
        
        guard let validData = data, validData.count > 0 else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength))
        }
        
        guard let jsonString = String(data: validData, encoding: .utf8) else {
            return .failure(AFError.responseSerializationFailed(reason: .stringSerializationFailed(encoding: .utf8)))
        }
        
        guard let modelT = JSONDeserializer<T>.deserializeFrom(json: jsonString) else {
            let error = AFError.HandyJsonError.parseModelError("Parse Model error")
            return .failure(AFError.responseSerializationFailed(reason: .jsonSerializationFailed(error: error)))
        }
        
        return .success(modelT)
    }
}

终于写完了扩展，赶紧体验一下：

Alamofire.request(urlString).validate()
    .responseHandyJsonModel(type: Model.self) { (response) in
        switch response.result {
        case .success(let model):
            print("request success: \(model)")
        case .failure(let error):
            Log.d("request failed: \(error)")
        }
}

Alamofire.request(urlString).validate()
    .responseHandyJsonModel(type: Model.self) { (response) in
        guard let model = response.result.value { return }
        print("model: \(model)")
}

真香！