Alamofire-Response

response为数据请求响应结果，封装了URLRequest、时间轴、请求错误信息，请求成功的数据等信息，方便开发人员取用。

1、业务层获取响应数据

Alamofire.request(url,method: .post,parameters: nil)
    .response{ response in
    print("response:\(response)")
}
复制代码

• response方法经过闭包向外传递响应数据

一、response-方法

方法实如今ResponseSerialization.swift文件中，是对响应结果的封装，提供序列化和不序列化请求结果的方法，其实都是对结果的一个处理封装，所以都放在该文件是合理的。下面看一下默认响应处理：

public func response(queue: DispatchQueue? = nil, completionHandler: @escaping (DefaultDataResponse) -> Void) -> Self {
    delegate.queue.addOperation {
        (queue ?? DispatchQueue.main).async {
            var dataResponse = DefaultDataResponse(
                request: self.request,
                response: self.response,
                data: self.delegate.data,
                error: self.delegate.error,
                timeline: self.timeline
            )
            dataResponse.add(self.delegate.metrics)
            completionHandler(dataResponse)
        }
    }
    return self
}
复制代码

• 该方法为DataRequest的扩展方法，返回self，能够继续链式调用，为方便调用，在Request类中这种写法比较常见
• 建立了DefaultDataResponse对象，并初始化，将请求过程当中全部参数整合

该方法在序列化文件中，都是对Request相关子类的扩展，以便于业务层调用。前面有讲到过，Request是面向业务层的，提供responseJSON、downloadProgress、response等方法。

DefaultDataResponse为一个结构体，在Response.swift文件中，是默认的存储结构。

二、Response-结构体

在Response.swift中声明了多个结构体，应对不一样的使用场景。分类以下：

DefaultDataResponse
DataResponse
DefaultDownloadResponse
DownloadResponse
复制代码

在业务层调用的response中对应的为DefaultDataResponse结构体，此处没有作序列化处理，只是对数据进行整合。业务层的方法调用和内部结构体的联系以下：

一、response{ response in } -> DefaultDataResponse 只作数据整合 二、responseJSON{ response in } -> DataResponse 对请求数据作序列化处理再整合 三、downloadProgress.response -> DefaultDownloadResponse 整合存储下载相关信息 四、downloadProgress.response(responseSerializer) -> DownloadResponse 整合存储下载相关信息

为何没有upload对应的结构体呢，由于upload返回结果就是普通的数据返回，以上提供的方法即可公用。

经过Request对象的一步步调用，最终数据会处理未Response的形式，经过闭包调用向业务层发送response类型消息。

2、DataResponseSerializer-序列化器

在Request类中提供了序列化处理和非序列化处理，能够根据须要来调用。下面看一下，序列化器是如何序列化的。方法入口以下：

Alamofire.request(url,method: .post,parameters: nil).responseJSON {
    (response) in
    switch response.result{
    case .success(let json):
        print("json:\(json)")
        break
    case .failure(let error):
        print("error:\(error)")
        break
    }
}
复制代码

• responseJSON就是获取一个json类型的数据，原始数据在方法内部被序列化过

public func responseJSON( queue: DispatchQueue? = nil, options: JSONSerialization.ReadingOptions = .allowFragments, completionHandler: @escaping (DataResponse<Any>) -> Void)
    -> Self
{
    return response(
        queue: queue,
        responseSerializer: DataRequest.jsonResponseSerializer(options: options),
        completionHandler: completionHandler
    )
}
复制代码

• jsonResponseSerializer其实是一个函数指针，供response内部调用，经过该函数来处理数据

jsonResponseSerializer实现：

public static func jsonResponseSerializer( options: JSONSerialization.ReadingOptions = .allowFragments)
    -> DataResponseSerializer<Any>
{
    return DataResponseSerializer { _, response, data, error in
        return Request.serializeResponseJSON(options: options, response: response, data: data, error: error)
    }
}
复制代码

• 实现闭包链接，共ResponseSerialization中的response方法内部调用

最终调用serializeResponseJSON方法来序列化数据。代码以下：

public static func serializeResponseJSON( options: JSONSerialization.ReadingOptions, response: HTTPURLResponse?, data: Data?, error: Error?)
    -> Result<Any>
{
    //代码省略
    do {
        let json = try JSONSerialization.jsonObject(with: validData, options: options)
        return .success(json)
    } catch {
        return .failure(AFError.responseSerializationFailed(reason: .jsonSerializationFailed(error: error)))
    }
}
复制代码

• 这里就能看到咱们熟悉的身影，经过JSONSerialization对数据作序列化处理
• 根据序列化结构返回.success或.failure

以上方法的调用以下：

public func response<T: DataResponseSerializerProtocol>( queue: DispatchQueue? = nil, responseSerializer: T, completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
    -> Self
{
    delegate.queue.addOperation {
        let result = responseSerializer.serializeResponse(
            self.request,
            self.response,
            self.delegate.data,
            self.delegate.error
        )
        var dataResponse = DataResponse<T.SerializedObject>(
            request: self.request,
            response: self.response,
            data: self.delegate.data,
            result: result,
            timeline: self.timeline
        )
        dataResponse.add(self.delegate.metrics)
        (queue ?? DispatchQueue.main).async { completionHandler(dataResponse) }
    }
    return self
}
复制代码

• 调用序列化方法，传入必要参数，对数据序列化处理，最终返回一个Result的枚举
• 将序列化产生的枚举result封装至dataResponse中，此时序列化到响应就全都完成
• 将结果经过闭包在主队列中向外发送

3、Result

是一个枚举，在response中传递的既是该枚举类型的变量，经过变量来判断数据请求是成功仍是失败。

.responseJSON { (response) in
    switch response.result {
        case .success(let json):
            print("json:\(json)")
            break
        case .failure(let error):
            print("error:\(error)")
            break
    }
}
复制代码

只有json序列化以后才会有以上枚举变量，来通知业务层序列化成功仍是失败。

4、总结

• 一、response在序列化器ResponseSerialization中初始化；
• 二、序列化器其实是Request类的扩展，方便经过闭包向业务层传递请求结果；
• 三、序列化器的Request的扩展方法中都返回self，以便于链式调用；
• 四、response帮助咱们统一管理请求过程当中的数据，请求成功、失败、时间轴等等，便于业务层处理；
• 五、Response为不一样请求类型，提供不一样的结构体类型来管理数据。