系列
一.response 分类
1.通过代码进入resopnse
SessionManager.default
.request(urlString)
//response
.response { (response) in
print(response)
}
//.response方法
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
}
2.分类
我们可以看到1中的代码使用了DefaultDataResponse,据此查看其它类型.通过分类的定义,即可以明确请求的网络响应数据没有经过序列化,为原始数据.
- DefaultDataResponse 用于存储(数据/上传)请求响应的没有序列化的数据.
- DataResponse 用于存储(数据/上传)请求响应的经过序列化的数据.
- DefaultDownloadResponse用于存储下载请求响应的没有序列化的数据.
- DownloadResponse用于存储下载请求响应的经过序列化的数据.
3.类型对比
1.DefaultDataResponse
/// Used to store all data associated with an non-serialized response of a data or upload request.
public struct DefaultDataResponse {
/// The URL request sent to the server.
public let request: URLRequest?
/// The server's response to the URL request.
public let response: HTTPURLResponse?
/// The data returned by the server.
public let data: Data?
/// The error encountered while executing or validating the request.
public let error: Error?
/// The timeline of the complete lifecycle of the request.
public let timeline: Timeline
var _metrics: AnyObject?
2.DataResponse
/// Used to store all data associated with a serialized response of a data or upload request.
public struct DataResponse<Value> {
/// The URL request sent to the server.
public let request: URLRequest?
/// The server's response to the URL request.
public let response: HTTPURLResponse?
/// The data returned by the server.
public let data: Data?
/// The result of response serialization.
public let result: Result<Value>
/// The timeline of the complete lifecycle of the request.
public let timeline: Timeline
/// Returns the associated value of the result if it is a success, `nil` otherwise.
public var value: Value? { return result.value }
/// Returns the associated error value if the result if it is a failure, `nil` otherwise.
public var error: Error? { return result.error }
var _metrics: AnyObject?
**分类的解释可以清楚看到是否序列化的区别,代码区别在于后者多了public let result: Result 这个字段.那么问题来了,如何序列化的?
二.response序列化
//1.调用responseJSON格式
SessionManager.default
.request(urlString)
// responseJSON
.responseJSON { (jsonResponse) in
print(jsonResponse)
}
//2.进入responseJSON方法
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
)
}
//3.response方法
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
}
代码分析:
- 在3.response方法中可以看到参数responseSerializer:DataResponseSerializerProtocol.此参数实现数据协议序列化协议.看看此协议:
public protocol DataResponseSerializerProtocol {
/// The type of serialized object to be created by this `DataResponseSerializerType`.
associatedtype SerializedObject
/// A closure used by response handlers that takes a request, response, data and error and returns a result.
var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<SerializedObject> { get }
}
此处可以明确序列化协议的闭包生成result,即let result = responseSerializer.serializeResponse(),为DataResponse的result属性,最后完成闭包返回DataResponse给用户.
- 在2中提供相应序列化实现 DataRequest.jsonResponseSerializer(options: options),点击查看即可明确.
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)
}
}
//继续查看,实现代码,简化显示示意
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)))
}
}
三.自定义序列化
继续查看API,.response方法可以传入responseSerializer,遵循DataResponseSerializerProtocol即可.通过框架提供的json序列化分析,我们完全可以自定义一个序列化实现.
SessionManager.default
.request(urlString)
//customer ResponseSerlize
.response(responseSerializer: customerResponseSerlize) { (lgDataResponse) in
print(lgDataResponse)
}
