前言
在Alamofire的整個(gè)流程里還有最關(guān)鍵的一環(huán)沒(méi)有探索，那就是Response和的使用和解析。
Response初探
先看一段簡(jiǎn)單代碼
SessionManager.default
.request(urlString)
.response { (response) in
print(response)
}
在請(qǐng)求的過(guò)程中，必須要先request再調(diào)用response，那為什么能夠?qū)崿F(xiàn)這種效果呢？
其實(shí)這個(gè)在之前分析Requset流程的時(shí)候，有一個(gè)串行queue，添加了response任務(wù)，在request初始化的時(shí)候這個(gè)queue是掛起狀態(tài)，如下所示
self.queue = {
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1
operationQueue.isSuspended = true
operationQueue.qualityOfService = .utility
return operationQueue
}()
在接收到請(qǐng)求完成的回調(diào)時(shí)，再設(shè)置了這個(gè)queue為不掛起狀態(tài)，可以執(zhí)行之前保存的response任務(wù)。這樣子就實(shí)現(xiàn)了必須是在request請(qǐng)求完成后，才能調(diào)用response的效果
func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
//其他代碼已省略
queue.isSuspended = false
}
Response內(nèi)容探索
點(diǎn)進(jìn)response里查看,這里做的操作就是上面說(shuō)的把response任務(wù)加到queue里，這里創(chuàng)建的是一個(gè)DefaultDataResponse類(lèi)型
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
}
- 點(diǎn)進(jìn)
DefaultDataResponse,發(fā)現(xiàn)這是一個(gè)結(jié)構(gòu)體，可以看到init方法保存了傳遞進(jìn)來(lái)的一些屬性 - 這里很好理解，在外界能通過(guò)
response打印里面的request,response等這些屬性，需要注意這兩個(gè)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
}
- 了解清楚里面是一個(gè)
response結(jié)構(gòu)體的初始化, 那么這時(shí)候需要知道，傳遞進(jìn)來(lái)保存的這些屬性都是什么呢？ -
request,response,timeline都很好理解，是取的當(dāng)前的，那我們?nèi)タ?code>self.delegate.data的data是怎么傳遞過(guò)來(lái)的
var dataResponse = DefaultDataResponse(
request: self.request,
response: self.response,
data: self.delegate.data,
error: self.delegate.error,
timeline: self.timeline
)
點(diǎn)進(jìn)去找到DataTaskDelegate里的data，發(fā)現(xiàn)其實(shí)返回的是mutableData,那么mutableData又為何物呢？
override var data: Data? {
if dataStream != nil {
return nil
} else {
return mutableData
}
}
在當(dāng)前DataTaskDelegate找mutableData，發(fā)現(xiàn)了mutableData.append(data)，現(xiàn)在很清楚了，我們外界的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是從哪里傳遞的過(guò)來(lái)的，很容易就找到它是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 }
}
//省略無(wú)關(guān)代碼
}
}
探索到這里已經(jīng)結(jié)束了，我們已經(jīng)知道
response是一個(gè)DefaultDataResponse結(jié)構(gòu)體init后的數(shù)據(jù)，數(shù)據(jù)是由DataTaskDelegate里的回調(diào)方法傳遞過(guò)去的，DataTaskDelegate是由SessionDelegate分派詳細(xì)任務(wù)的，SessionDelegate監(jiān)聽(tīng)的是系統(tǒng)的URLSession的代理回調(diào)。
整個(gè)流程相當(dāng)清晰，再一次感受到了Alamofire的強(qiáng)大之處!
DataResponseSerializer
我們經(jīng)常會(huì)對(duì)response.data的數(shù)據(jù)要做序列化處理，才能滿足我們的功能需求。這時(shí)候可以用到Alamofire里的自定義響應(yīng)序列器了,先看看下面的使用代碼
let dlResponseSerlize = DataResponseSerializer<String>.init(serializeResponse: { (request, response, data, error) -> Result<String> in
print("原始數(shù)據(jù) : \(response)")
return .success("TestResponse!!!")
})
SessionManager.default
.request(urlString)
.response { (response) in
print(response)
}
.response(responseSerializer: dlResponseSerlize) { (dlDataResponse) in
print(dlDataResponse)
}
- 創(chuàng)建了一個(gè)
dlResponseSerlize,這里把response的原始數(shù)據(jù)修改成了返回自定義的.success("TestResponse!!!") - 通過(guò)
.response(responseSerializer: dlResponseSerlize)使用了這個(gè)自定義的序列器，返回了我們自定義的響應(yīng)結(jié)果 - 那我們?nèi)タ纯催@里是怎么實(shí)現(xiàn)的吧，先點(diǎn)擊去看看自定義的
DataResponseSerializer,點(diǎn)進(jìn)去找到他的init方法
public init(serializeResponse: @escaping (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>) {
self.serializeResponse = serializeResponse
}
- 發(fā)現(xiàn)這里把這個(gè)自定義序列器保存起來(lái)了，其實(shí)保存的就是我們外界的
print("原始數(shù)據(jù) : \(response)") return .success("TestResponse!!!")這段代碼 - 那么什么時(shí)候調(diào)用的這段代碼呢？
- 回到外界點(diǎn)進(jìn)去
.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
}
- 可以發(fā)現(xiàn)這是一個(gè)泛型
T，然后delegate.queue.addOperation是把當(dāng)前整個(gè)序列化的任務(wù)加到這個(gè)隊(duì)列里 - 這個(gè)
result就調(diào)用了我們之前保存的自定義序列器的代碼，同時(shí)再給dataResponse使用 - 這個(gè)自定義序列器流程就很清楚了，其實(shí)就是在返回
response的時(shí)候包裝了一下response，使其能返回我們需要的響應(yīng)結(jié)果
Alamofire還默認(rèn)提供了responseJSON序列器，直接把返回的結(jié)果轉(zhuǎn)為json使用
SessionManager.default
.request(urlString)
.response { (response) in
print(response)
}.responseJSON { (jsonResponse) in
print(jsonResponse)
}
點(diǎn)進(jìn)去看看responseJSON的實(shí)現(xiàn),這里返回的是一個(gè)調(diào)用了response方法的結(jié)果，
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
)
}
點(diǎn)進(jìn)response方法看看，這個(gè)方法是和我們上面自定義序列器的方法是一模一樣的，很容易想到，其實(shí)這里的不同只是傳遞的參數(shù)不同，這里傳遞的泛型參數(shù)不同DataRequest.jsonResponseSerializer(options: options),找到這個(gè)json序列器，發(fā)現(xiàn)這里返回的是Request.serializeResponseJSON的結(jié)果
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)
}
}
- 繼續(xù)點(diǎn)進(jìn)去看看,發(fā)現(xiàn)這里的關(guān)鍵代碼就是調(diào)用了
JSONSerialization.jsonObject方法，得到了json處理后的結(jié)果，然后再調(diào)用return .success(json) - 這和我們自定義序列器的簡(jiǎn)直一模一樣，看到這里不禁感慨，
Alamofire設(shè)計(jì)的真是巧妙，通過(guò)一個(gè)泛型T, 讓本身提供的序列化器和使用者去自定義的序列器能夠使用同一個(gè)方法來(lái)實(shí)現(xiàn)
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)))
}
}
總結(jié)
Alamofire把整個(gè)響應(yīng)的流程簡(jiǎn)化成了一個(gè)靜態(tài)的方法調(diào)用，并且用鏈?zhǔn)降姆绞絹?lái)處理異步的Response解析。由于是鏈?zhǔn)降?，我們可以在?qǐng)求響應(yīng)后，做一系列validate驗(yàn)證結(jié)果，result處理，自定義序列器等操作，可以滿足開(kāi)發(fā)中的很多需要。
