Alamofire-Request知识补充
一、请求适配器-RequestAdapter
目的是为了处理Request添加装饰,一个典型的例子是为每一个请求添加token请求，或者对Request重定向。
public protocol RequestAdapter {
func adapt(_ urlRequest: URLRequest) throws -> URLRequest
}
RequestAdapter是一个协议,我们需要自己来实现这个协议。
class JNAdapter: RequestAdapter{
func adapt(_ urlRequest: URLRequest) throws -> URLRequest {
// token
// request 处理
var request = urlRequest
request.setValue("xxxxxx", forHTTPHeaderField: "token")
//request 重定向
let newUrlRequest = URLRequest.init(url: URL(string: "http://www.douban.com/j/app/radio/channels")!)
return newUrlRequest
}
}
1.定义JNAdapter遵循RequestAdapter协议
2.实现adapt,实现自己需要处理的逻辑
3.SessionManager.default.adapter = JNAdapter(),指定adapter
二、自定义验证-validate
网络请求返回的状态码一般是200的段是属于请求成功,但实际开发中,结合业务和后台接口的情况,需要自定义验证逻辑。
SessionManager.default.request(urlStr, method: .get, parameters: ["username":"Jensen","password":"123456"])
.response { (response) in
debugPrint(response)
}.validate { (request, response, data) -> Request.ValidationResult in
guard let _ = data else{
return .failure(NSError.init(domain: "error", code: 100, userInfo: nil))
}
let code = response.statusCode
if code == 404 {
return .failure(NSError.init(domain: "error", code:101, userInfo: nil))
}
return .success
}
三、RequestRetrier-请求重试器
目的是控制请求的重试机制，一个典型的例子是当某个特殊的请求失败后，是否重试。
open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
//......省略
// Determine whether an error has occurred
var error: Error? = error
if request.delegate.error != nil {
error = request.delegate.error
}
/// If an error occurred and the retrier is set, asynchronously ask the retrier if the request
/// should be retried. Otherwise, complete the task by notifying the task delegate.
if let retrier = retrier, let error = error {
retrier.should(sessionManager, retry: request, with: error) { [weak self] shouldRetry, timeDelay in
guard shouldRetry else { completeTask(session, task, error) ; return }
DispatchQueue.utility.after(timeDelay) { [weak self] in
guard let strongSelf = self else { return }
let retrySucceeded = strongSelf.sessionManager?.retry(request) ?? false
if retrySucceeded, let task = request.task {
strongSelf[task] = request
return
} else {
completeTask(session, task, error)
}
}
}
} else {
completeTask(session, task, error)
}
}
}
当SessionDelegate完成请求，如果发生错误，会来到if let retrier = retrier, let error = error,判断Retrier重试闭包是否存在。
retrier 也是继承协议的处理方式,实现参考 adapter
class JNRetrier: RequestRetrier{
func should(_ manager: SessionManager, retry request: Request, with error: Error, completion: @escaping RequestRetryCompletion) {
completion(true,1)//重试
completion(false,0)//不重试
}
}
1.实现RequestRetrier协议的should方法
2.指定retrierSessionManager.default.retrier = JNRetrier()3.必须要指定条件调用completion(false,0)`停止重试，否则造成死循环.
四、Result
请求返回后,需要序列化后，才是我们最终想要的。
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
)
}
return self
}
result是经过了 responseSerializer.serializeResponse 序列化处理的结果
result 的结果最终传入到了dataResponse
public enum Result<Value> {
case success(Value)
case failure(Error)
// 提供成功还有失败的校验
public var isSuccess: Bool {... }
public var isFailure: Bool {...}
public var value: Value? {...}
public var error: Error? {... }
}
返回结果只有成功和失败，设计成了枚举。
Result实现了CustomStringConvertible和 CustomDebugStringConvertible协议 ：
extension Result: CustomStringConvertible {
public var description: String {
// 就是返回 "SUCCESS" 和 "FAILURE" 的标识
}
}
extension Result: CustomDebugStringConvertible {
public var debugDescription: String {
// 返回标识的同时，还返回了具体内容
}
}
可以打印错误详细的信息。
五、Timeline 时间轴
Alamofire提供了Timeline 时间轴,开发者可以通过Timeline快速得到序列化时间,请求时间等，有助于排查问题，优化性能。
timeline: Timeline: {
"Request Start Time": 588178187.197,
"Initial Response Time": 588178187.537,
"Request Completed Time": 588178187.543,
"Serialization Completed Time": 588178187.543,
"Latency": 0.340 secs,
"Request Duration": 0.346 secs,
"Serialization Duration": 0.000 secs,
"Total Duration": 0.346 secs }
在TaskDelegate的初始化中:
init(task: URLSessionTask?) {
_task = task
self.queue = {
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1
operationQueue.isSuspended = true
operationQueue.qualityOfService = .utility
return operationQueue
}()
}
1.初始化OperationQueue队列
2.指定队列maxConcurrentOperationCount=1,为串行队列，保证每一个任务顺序执行
3.operationQueue.isSuspended = true队列为挂起状态.
那么这个队列在什么时候开始执行呢?
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 }
if
let downloadDelegate = self as? DownloadTaskDelegate,
let resumeData = (error as NSError).userInfo[NSURLSessionDownloadTaskResumeData] as? Data
{
downloadDelegate.resumeData = resumeData
}
}
queue.isSuspended = false
}
}
我们在TaskDelegate请求完成的代理方法中看到queue.isSuspended = false,说明是这个时候队列开始执行。
根据timeline记录和计算得出的结果,我们知道肯定会记录请求的开始时间，结束时间等等。顺着这个思路,我们猜测请求的开始时间应该是在task.resume记录的:
open func resume() {
guard let task = task else { delegate.queue.isSuspended = false ; return }
if startTime == nil { startTime = CFAbsoluteTimeGetCurrent() }
task.resume()
NotificationCenter.default.post(
name: Notification.Name.Task.DidResume,
object: self,
userInfo: [Notification.Key.Task: task]
)
}
正如我们所料,startTime = CFAbsoluteTimeGetCurrent(),在这里将请求的开始时间保存在startTime。
在Request的初始化中:
init(session: URLSession, requestTask: RequestTask, error: Error? = nil) {
self.session = session
switch requestTask {
case .data(let originalTask, let task):
taskDelegate = DataTaskDelegate(task: task)
self.originalTask = originalTask
case .download(let originalTask, let task):
taskDelegate = DownloadTaskDelegate(task: task)
self.originalTask = originalTask
case .upload(let originalTask, let task):
taskDelegate = UploadTaskDelegate(task: task)
self.originalTask = originalTask
case .stream(let originalTask, let task):
taskDelegate = TaskDelegate(task: task)
self.originalTask = originalTask
}
delegate.error = error
delegate.queue.addOperation { self.endTime = CFAbsoluteTimeGetCurrent() }
print(delegate.queue.operationCount)
}
在操作队列中加入任务{ self.endTime = CFAbsoluteTimeGetCurrent() },队列中加入的第一个任务，当请求结束时，队列resume,将记录结束时间到endTime
func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
}
在请求第一次响应返回数据时,记录时间到initialResponseTime,我们看看timeline是什么时候初始化的?
response中任务到队列中,可以知道是在队列执行到这个任务时,初始化timeline
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
}
进入self.timeline,可以看到timeline设置:
var timeline: Timeline {
let requestStartTime = self.startTime ?? CFAbsoluteTimeGetCurrent()
let requestCompletedTime = self.endTime ?? CFAbsoluteTimeGetCurrent()
let initialResponseTime = self.delegate.initialResponseTime ?? requestCompletedTime
return Timeline(
requestStartTime: requestStartTime,
initialResponseTime: initialResponseTime,
requestCompletedTime: requestCompletedTime,
serializationCompletedTime: CFAbsoluteTimeGetCurrent()
)
}
requestStartTime,requestCompletedTime,initialResponseTime是由之前保存的startTime,endTime,initialResponseTime包装而成。serializationCompletedTime是执行这个闭包的时间。
timeline初始化及数据计算:
public init(
requestStartTime: CFAbsoluteTime = 0.0,
initialResponseTime: CFAbsoluteTime = 0.0,
requestCompletedTime: CFAbsoluteTime = 0.0,
serializationCompletedTime: CFAbsoluteTime = 0.0)
{
self.requestStartTime = requestStartTime
self.initialResponseTime = initialResponseTime
self.requestCompletedTime = requestCompletedTime
self.serializationCompletedTime = serializationCompletedTime
self.latency = initialResponseTime - requestStartTime
self.requestDuration = requestCompletedTime - requestStartTime
self.serializationDuration = serializationCompletedTime - requestCompletedTime
self.totalDuration = serializationCompletedTime - requestStartTime
}
为什么能够对这些时间记录,主要是通过队列同步控制实现的。在一些核心的点保存当前时间! 比如：endTime就是在下载完成那个瞬间让队列执行保存这个时间。
startTime, initialResponseTime 保存在代理中。
如果没有设置值，那么就在当时调用的时候重置当前时间
Timeline 的其他时间就是通过已知的 initialResponseTime 和 requestStartTime、requestCompletedTime 、serializationCompletedTime 计算得出的。
