Alamofire(四) Response源码解析

前言

在Alamofire的整个流程里还有最关键的一环没有探索，那就是Response和的使用和解析。

Response初探

先看一段简单代码

SessionManager.default
            .request(urlString)
            .response { (response) in
                print(response)
            }

在请求的过程中，必须要先request再调用response，那为什么能够实现这种效果呢？
其实这个在之前分析Requset流程的时候，有一个串行queue，添加了response任务，在request初始化的时候这个queue是挂起状态，如下所示

self.queue = {
            let operationQueue = OperationQueue()

            operationQueue.maxConcurrentOperationCount = 1
            operationQueue.isSuspended = true
            operationQueue.qualityOfService = .utility

            return operationQueue
        }()

在接收到请求完成的回调时，再设置了这个queue为不挂起状态，可以执行之前保存的response任务。这样子就实现了必须是在request请求完成后，才能调用response的效果

 func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
 //其他代码已省略
    queue.isSuspended = false
 }

Response内容探索

点进response里查看,这里做的操作就是上面说的把response任务加到queue里，这里创建的是一个DefaultDataResponse类型

 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
    }

点进DefaultDataResponse,发现这是一个结构体，可以看到init方法保存了传递进来的一些属性
这里很好理解，在外界能通过response打印里面的request,response等这些属性，需要注意这两个response是不同的

 public init(
        request: URLRequest?,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?,
        timeline: Timeline = Timeline(),
        metrics: AnyObject? = nil)
    {
        self.request = request
        self.response = response
        self.data = data
        self.error = error
        self.timeline = timeline
    }

了解清楚里面是一个response结构体的初始化, 那么这时候需要知道，传递进来保存的这些属性都是什么呢？
request,response,timeline都很好理解，是取的当前的，那我们去看self.delegate.data的data是怎么传递过来的

var dataResponse = DefaultDataResponse(
                    request: self.request,
                    response: self.response,
                    data: self.delegate.data,
                    error: self.delegate.error,
                    timeline: self.timeline
                )

点进去找到DataTaskDelegate里的data，发现其实返回的是mutableData,那么mutableData又为何物呢？

override var data: Data? {
        if dataStream != nil {
            return nil
        } else {
            return mutableData
        }
    }

在当前DataTaskDelegate找mutableData，发现了mutableData.append(data)，现在很清楚了，我们外界的response.data就是从这里获取的

 func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }

        if let dataTaskDidReceiveData = dataTaskDidReceiveData {
            dataTaskDidReceiveData(session, dataTask, data)
        } else {
            if let dataStream = dataStream {
                dataStream(data)
            } else {
                mutableData.append(data)
            }

            let bytesReceived = Int64(data.count)
            totalBytesReceived += bytesReceived
            let totalBytesExpected = dataTask.response?.expectedContentLength ?? NSURLSessionTransferSizeUnknown

            progress.totalUnitCount = totalBytesExpected
            progress.completedUnitCount = totalBytesReceived

            if let progressHandler = progressHandler {
                progressHandler.queue.async { progressHandler.closure(self.progress) }
            }
        }
    }

同理，去找error是从哪里传递的过来的，很容易就找到它是didCompleteWithError里赋值的

func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        if let taskDidCompleteWithError = taskDidCompleteWithError {
            taskDidCompleteWithError(session, task, error)
        } else {
            if let error = error {
                if self.error == nil { self.error = error }
            }
            //省略无关代码
        }
    }

探索到这里已经结束了，我们已经知道response是一个DefaultDataResponse结构体init后的数据，数据是由DataTaskDelegate里的回调方法传递过去的，DataTaskDelegate是由SessionDelegate分派详细任务的，SessionDelegate监听的是系统的URLSession的代理回调。
整个流程相当清晰，再一次感受到了Alamofire的强大之处!

DataResponseSerializer

我们经常会对response.data的数据要做序列化处理，才能满足我们的功能需求。这时候可以用到Alamofire里的自定义响应序列器了,先看看下面的使用代码

let dlResponseSerlize = DataResponseSerializer<String>.init(serializeResponse: { (request, response, data, error) -> Result<String> in
            print("原始数据 : \(response)")
            return .success("TestResponse!!!")
        })
        SessionManager.default
            .request(urlString)
            .response { (response) in
                print(response)
            }
            .response(responseSerializer: dlResponseSerlize) { (dlDataResponse) in
                print(dlDataResponse)
            }

创建了一个dlResponseSerlize,这里把response的原始数据修改成了返回自定义的.success("TestResponse!!!")
通过.response(responseSerializer: dlResponseSerlize)使用了这个自定义的序列器，返回了我们自定义的响应结果
那我们去看看这里是怎么实现的吧，先点击去看看自定义的DataResponseSerializer,点进去找到他的init方法

  public init(serializeResponse: @escaping (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>) {
        self.serializeResponse = serializeResponse
    }

发现这里把这个自定义序列器保存起来了，其实保存的就是我们外界的print("原始数据 : \(response)") return .success("TestResponse!!!")这段代码
那么什么时候调用的这段代码呢？
回到外界点进去.response(responseSerializer: dlResponseSerlize)

 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
    }

可以发现这是一个泛型T，然后delegate.queue.addOperation是把当前整个序列化的任务加到这个队列里
这个result就调用了我们之前保存的自定义序列器的代码，同时再给dataResponse使用
这个自定义序列器流程就很清楚了，其实就是在返回response的时候包装了一下response，使其能返回我们需要的响应结果

Alamofire还默认提供了responseJSON序列器，直接把返回的结果转为json使用

SessionManager.default
            .request(urlString)
            .response { (response) in
                print(response)
            }.responseJSON { (jsonResponse) in
                print(jsonResponse)
        }

点进去看看responseJSON的实现,这里返回的是一个调用了response方法的结果，

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

点进response方法看看，这个方法是和我们上面自定义序列器的方法是一模一样的，很容易想到，其实这里的不同只是传递的参数不同，这里传递的泛型参数不同DataRequest.jsonResponseSerializer(options: options),找到这个json序列器，发现这里返回的是Request.serializeResponseJSON的结果

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

继续点进去看看,发现这里的关键代码就是调用了JSONSerialization.jsonObject方法，得到了json处理后的结果，然后再调用return .success(json)
这和我们自定义序列器的简直一模一样，看到这里不禁感慨，Alamofire设计的真是巧妙，通过一个泛型T, 让本身提供的序列化器和使用者去自定义的序列器能够使用同一个方法来实现

 public static func serializeResponseJSON(
        options: JSONSerialization.ReadingOptions,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?)
        -> Result<Any>
    {
        guard error == nil else { return .failure(error!) }

        if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success(NSNull()) }

        guard let validData = data, validData.count > 0 else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength))
        }

        do {
            let json = try JSONSerialization.jsonObject(with: validData, options: options)
            return .success(json)
        } catch {
            return .failure(AFError.responseSerializationFailed(reason: .jsonSerializationFailed(error: error)))
        }
    }

总结

Alamofire把整个响应的流程简化成了一个静态的方法调用，并且用链式的方式来处理异步的Response解析。由于是链式的，我们可以在请求响应后，做一系列validate验证结果，result处理，自定义序列器等操作，可以满足开发中的很多需要。