我相信可能有80%的同学使用AFNetworking或者Alamofire处理网络事件，并且这两个框架都提供了丰富的功能，我也相信很多人都做了二次封装，但事实上，这个二次封装却又异常简单或者是简陋。这篇文章的内容是Task代理，是一篇很独立的文章，大家可以通过这篇文章了解iOS中网络开发是怎么一回事。
那么一条最普通的网络请求，究竟是怎样的一个过程？首先我们根据一个URL和若干个参数生成Request，然后根据Request生成一个会话Session，再根据这个Session生成Task，我们开启Task就完成了这个请求。当然这一过程之中还会包含重定向，数据上传，挑战，证书等等一系列的配置信息。
我们再聊聊代理的问题，不管是在网络请求中，还是再其他的地方，代理都类似于一个管理员的身份。这在业务架构中是一个很好的主意。假如我把代理想象成一个人，那么这个人的工作是什么呢？
提供我所需要的数据，这一点很重要。获取的数据也分两种：加工过的和未加工过的。举个例子，有一个控制器，里边需要处理好几个不同类型的cell，每个cell都有属于自己的适配器来控制样式和数据处理，面对这种情况，可以设计一个代理，每当刷新界面的时候，直接从代理中请求处理过的适配器数据，那么这种情况下的数据就是被加工过的，如果数据加工是一个复杂的工作，可以设计一个数据加工的代理。这就涉及了下边的代理的另外一项工作。
提供处理业务的方法，这往往被用于事件的传递。这是一种狭义上的代理，是一个协议。在开发中,不管是view还是Controller，都可以利用代理传递事件。但我们这里说的不是协议，协议必须要求我们实现它的属性和方法，这对上边提到的‘人’是不友好的。在真实的理想的场景中，我和代理的交互只有两种情况：
给我想要的数据
我知道这个业务你比较精通，当有和你相关的事情的时候，我会通知你
如果对上边的内容不太明白，只需要明白，有的代理是一个协议，有的代理是一个'人'，在某些让你头疼的复杂的业务中，用代理'人'去处理。我在想是不是不叫代理，叫Manager更合适。
URLSessionTask
(1)获取Data
(2)下载
(3)上传
(4)Stream， 这个在这篇中不做讲解
上边图中表示了一种继承关系，与之相对应的
代理如下图：
下边详细讲解这些代理方法。
TaskDelegate
TaskDelegate位于继承链的最底层，因此它提供了一些最基础的东西，这些东西也是其他Delegate共享的，我们先看看属性：
// MARK: Properties
/// The serial operation queue used to execute all operations after the task completes.
open let queue: OperationQueue
/// The data returned by the server.
public var data: Data? { return nil }
/// The error generated throughout the lifecyle of the task.
public var error: Error?
var task: URLSessionTask? {
didSet { reset() }
}
var initialResponseTime: CFAbsoluteTime?
var credential: URLCredential?
var metrics: AnyObject? // URLSessionTaskMetrics
(1)queue: OperationQueue 很明显这是一个队列，队列中可以添加很多operation。队列是可以被暂停的，通过把isSuspended设置为true就可以让队列中的所有operation暂停，直到isSuspended设置为false后，operation才会开始执行。在Alamofire中，放入该队列的operation有一下几种情况：
注意：该队列会在任务完成之后把isSuspended设置为false
一个Request的endTime，在任务完成后调用，就可以为Request设置请求结束时间
response处理，Alamofire中的响应回调是链式的，原理就是把这些回调函数通过operation添加到队列中，因此也保证了回调函数的访问顺序是正确的
上传数据成功后，删除临时文件，这个后续的文章会解释的
(2)data: Data? 表示服务器返回的Data，这个可能为空
(3)error: Error?表示该代理生命周期内有可能出现的错误，这一点很重要，我们在写一个代理或者manager的时候，可以添加这么一个错误属性，专门抓取生命周期内的错误。
(4)task: URLSessionTask? 表示一个task，对于本代理而言，task是很重要的一个属性。
(5)initialResponseTime: CFAbsoluteTime? 当task是URLSessionDataTask时，表示接收到数据的时间；当task是URLSessionDownloadTask时，表示开始写数据的时间；当task是URLSessionUploadTask时，表示上传数据的时间；
(6)credential: URLCredential? 表示证书，如果给该代理设置了这个属性，在它里边的证书验证方法中会备用到
(7)metrics: AnyObject? apple提供了一个统计task信息的类URLSessionTaskMetrics,可以统计跟task相关的一些信息，包括和task相关的所有事务，task的开始和结束时间，task的重定向的次数
上边的这些属性中，可以留意一下queue的使用方法，尽量为设计的代理添加错误处理机制。
Alamofire使用类似Properties，Lifecycle等等关键字来分割文件的，看完了上边的属性，我们在看看Lifecycle。
// MARK: Lifecycle
init(task: URLSessionTask?) {
self.task = task
self.queue = {
let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1
operationQueue.isSuspended = true
operationQueue.qualityOfService = .utility
return operationQueue
}()
}
func reset() {
error = nil
initialResponseTime = nil
}
reset函数把error和initialResponseTime都置为nil，这个没什么好说的，在init函数中队列的创建很有意思。在swift中，如果我们要创建一个对象，不管是view还是别的，都可以采用这样的方式：创建一个函数，然后立刻调用，这很像JavaScript的用法。
lazy var label: UILabel = {
let view = UILabel()
view.backgroundColor = .clear
view.textAlignment = .center
view.textColor = .white
view.font = .boldSystemFont(ofSize: 18)
self.contentView.addSubview(view)
return view
}()
operationQueue.isSuspended = true可以保证队列中的operation都是暂停状态，正常情况下，operation在被加入到队列中后，会尽快执行。
在swift中函数是一等公民，可以当参数和返回值来使用。同oc的block一样，我们可以把他们当成一个属性，目的是提前告诉代理当遇到指定的事件时应该怎么做？在YYModel中有一小段代码就是关于Block当返回值的妙用。我们看看TaskDelegate下的四个相关函数：
// MARK: URLSessionTaskDelegate
var taskWillPerformHTTPRedirection: ((URLSession, URLSessionTask, HTTPURLResponse, URLRequest) -> URLRequest?)?
var taskDidReceiveChallenge: ((URLSession, URLSessionTask, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))?
var taskNeedNewBodyStream: ((URLSession, URLSessionTask) -> InputStream?)?
var taskDidCompleteWithError: ((URLSession, URLSessionTask, Error?) -> Void)?
我们先看第一个函数，这个函数对应的代理方法如下：
@objc(URLSession:task:willPerformHTTPRedirection:newRequest:completionHandler:)
func urlSession(
_ session: URLSession,
task: URLSessionTask,
willPerformHTTPRedirection response: HTTPURLResponse,
newRequest request: URLRequest,
completionHandler: @escaping (URLRequest?) -> Void)
{
var redirectRequest: URLRequest? = request
if let taskWillPerformHTTPRedirection = taskWillPerformHTTPRedirection {
redirectRequest = taskWillPerformHTTPRedirection(session, task, response, request)
}
completionHandler(redirectRequest)
}
上边的函数处理的问题是请求重定向问题，我们大概讲一下重定向是怎么一回事：Web服务器有时会返回重定向响应而不是成功的报文。Web服务器可以将浏览器重定向到其他地方来执行请求。重定向响应由返回码3XX说明。Location响应首部包含了内容的新地址或优选地址的URI重定向可用于下列情况：
(1)永久撤离的资源：资源可能被移动到新的位置，或者被重新命名，有了一个新的URI。Web服务器返回301 Moved Permanently
(2)临时撤离的资源：如果资源被临时撤离或重命名，Web服务器返回303 See Other 或307 Temproary Redirect
(3)URL增强：服务器通常用重定向来重写URL，往往用于嵌入上下文。Web服务器返回303 See Other 或307 Temproary Redirect
(4)负载均衡：如果一个超载的服务器收到一条请求，服务器可以将客户端重新定向到一个负载不大的服务器。Web服务器返回303 See Other 或307 Temproary Redirect
(5)服务器关联：Web服务器可能会有某些用户的本地信息，服务器可以将客户端重新定向到包含那个客户端信息的服务器上去。Web服务器返回303 See Other 或307 Temproary Redirect
(6)规范目录名称：客户端请求的URI是一个不带尾部斜线的目录名时，大多数服务器都会将客户端重定向到Hige加了尾部斜线的URI上。
上边的重定向函数要求返回一个redirectRequest，就是重定向的Request，Alamofire的处理方法就是，如果给代理的重定向处理函数赋值了，就返回代理函数的返回值，否则返回服务器返回的Request
第二个函数用于处理验证相关的事务。我们先讲讲disposition,他的类型是URLSession.AuthChallengeDisposition,其实就是一个枚举：
@available(iOS 7.0, *)
public enum AuthChallengeDisposition : Int {
case useCredential
case performDefaultHandling
case cancelAuthenticationChallenge
case rejectProtectionSpace
}
这个授权配置一共有四个选项：
useCredential 表示使用证书
performDefaultHandling 表示采用默认的方式，这个方式跟服务器返回authenticationMethod有很大关系，我简单列一些常用的method
NSURLAuthenticationMethodHTTPBasic 基本认证
NSURLAuthenticationMethodHTTPDigest 摘要认证
NSURLAuthenticationMethodClientCertificate 客户端证书认证
NSURLAuthenticationMethodServerTrust 表示返回的证书要使用serverTrust创建
cancelAuthenticationChallenge 表示取消认证
rejectProtectionSpace 表示拒绝认证
对于验证而言，有三种方式：
1.客户端验证
2.服务器验证
3.双向验证
@objc(URLSession:task:didReceiveChallenge:completionHandler:)
func urlSession(
_ session: URLSession,
task: URLSessionTask,
didReceive challenge: URLAuthenticationChallenge,
completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
{
var disposition: URLSession.AuthChallengeDisposition = .performDefaultHandling
var credential: URLCredential?
if let taskDidReceiveChallenge = taskDidReceiveChallenge {
(disposition, credential) = taskDidReceiveChallenge(session, task, challenge)
} else if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
let host = challenge.protectionSpace.host
if
let serverTrustPolicy = session.serverTrustPolicyManager?.serverTrustPolicy(forHost: host),
let serverTrust = challenge.protectionSpace.serverTrust
{
if serverTrustPolicy.evaluate(serverTrust, forHost: host) {
disposition = .useCredential
credential = URLCredential(trust: serverTrust)
} else {
disposition = .cancelAuthenticationChallenge
}
}
} else {
if challenge.previousFailureCount > 0 {
disposition = .rejectProtectionSpace
} else {
credential = self.credential ?? session.configuration.urlCredentialStorage?.defaultCredential(for: challenge.protectionSpace)
if credential != nil {
disposition = .useCredential
}
}
}
completionHandler(disposition, credential)
}
如果服务器需要验证客户端的，我们只需要给TaskDelegate的 var taskDidReceiveChallenge: ((URLSession, URLSessionTask, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))?赋值就行了。
这里有一个很重要的问题，HTTPS并不会触发上边的回调函数，原因就是NSURLSession内部有一个根证书，内部会跟服务器的证书进行验证，如果服务器的证书是证书机构颁发的话，就可以顺利通过验证，否则会报错。
另一个很重要的问题是，上边的方法在何种情况下触发，按照apple的说法URL Session Programming Guide,当服务器响应头中包含WWW-Authenticate
或者使用proxy authenticatio
nTLS trust validation
时，上边的方法就会被触发，其他情况下都不会触发。
Alamofire是双向验证的
双向验证的过程：
()1当服务器返回的challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust时，服务器提供了一个服务器信任的证书，但这个证书也仅仅是服务器自己信任的，攻击者完全可以提供一个证书骗过客户端，基于这个问题，客户端需要验证服务端的证书
(2)Alamofire中通过ServerTrustPolicy.swift这个类来验证证书，大概过程就是拿本地的证书跟服务端返回的证书进行对比，如果客户端存在相同的证书就表示通过，这个过程我会在ServerTrustPolicy.swift那篇文章中给出详细的解答
因此，客户端和服务端要建立SSL只需要两步就行了：
1.服务端返回WWW-Authenticate响应头，并返回自己信任证书
2.客户端验证证书，然后用证书中的公钥把数据加密后发送给服务端
第三个函数：
///This delegate method is called under two circumstances:
///To provide the initial request body stream if the task was created with uploadTask(withStreamedRequest:)
///To provide a replacement request body stream if the task needs to resend a request that has a body stream because of an authentication challenge or other recoverable server error.
///Note
///You do not need to implement this if your code provides the request body using a file URL or an NSData object.
@objc(URLSession:task:needNewBodyStream:)
func urlSession(
_ session: URLSession,
task: URLSessionTask,
needNewBodyStream completionHandler: @escaping (InputStream?) -> Void)
{
var bodyStream: InputStream?
if let taskNeedNewBodyStream = taskNeedNewBodyStream {
bodyStream = taskNeedNewBodyStream(session, task)
}
completionHandler(bodyStream)
}
当给task的Request提供一个body stream时才会调用，我们不需要关心这个方法，即使我们通过fileURL或者NSData上传数据时，该函数也不会被调用，使用场景很少。
第四个函数：
@objc(URLSession:task: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 }
if
let downloadDelegate = self as? DownloadTaskDelegate,
let resumeData = (error as NSError).userInfo[NSURLSessionDownloadTaskResumeData] as? Data
{
downloadDelegate.resumeData = resumeData
}
}
queue.isSuspended = false
}
}
该函数在请求完成后被调用，值得注意的是error不为nil的情况，除了给自身的error属性赋值外，针对下载任务做了特殊处理，就是把当前已经下载的数据保存在downloadDelegate.resumeData中，有点像断点下载。
DataTaskDelegate
DataTaskDelegate继承自TaskDelegate,实现了URLSessionDataDelegate协议。因此下边我们也会讲解URLSessionDataDelegate协议的方法。我们还是先看这里边的属性：
// MARK: Properties
var dataTask: URLSessionDataTask { return task as! URLSessionDataTask }
override var data: Data? {
if dataStream != nil {
return nil
} else {
return mutableData
}
}
var progress: Progress
var progressHandler: (closure: Request.ProgressHandler, queue: DispatchQueue)?
var dataStream: ((_ data: Data) -> Void)?
private var totalBytesReceived: Int64 = 0
private var mutableData: Data
private var expectedContentLength: Int64?
(1)dataTask: URLSessionDataTask DataTaskDelegate管理URLSessionDataTask
(2)data: Data? 同样是返回Data，但这里有一点不同，如果定义了dataStream方法的话，这个data返回为nil
(3)progress: Progress 进度
(4)progressHandler 这不是函数，是一个元组，什么时候调用，在下边的方法中给出说明
(5)dataStream 自定义的数据处理函数
(6)totalBytesReceived 已经接受的数据
(7)mutableData 保存数据的容器
(8)expectedContentLength 需要接受的数据的总大
DataTaskDelegate的生命周期：
// MARK: Lifecycle
override init(task: URLSessionTask?) {
mutableData = Data()
progress = Progress(totalUnitCount: 0)
super.init(task: task)
}
override func reset() {
super.reset()
progress = Progress(totalUnitCount: 0)
totalBytesReceived = 0
mutableData = Data()
expectedContentLength = nil
}
这些没什么好说的，我们在看看有哪些函数：
// MARK: URLSessionDataDelegate
var dataTaskDidReceiveResponse: ((URLSession, URLSessionDataTask, URLResponse) -> URLSession.ResponseDisposition)?
var dataTaskDidBecomeDownloadTask: ((URLSession, URLSessionDataTask, URLSessionDownloadTask) -> Void)?
var dataTaskDidReceiveData: ((URLSession, URLSessionDataTask, Data) -> Void)?
var dataTaskWillCacheResponse: ((URLSession, URLSessionDataTask, CachedURLResponse) -> CachedURLResponse?)?
URLSessionDataDelegate有四个函数，我们先看第一个函数：
func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
didReceive response: URLResponse,
completionHandler: @escaping (URLSession.ResponseDisposition) -> Void)
{
var disposition: URLSession.ResponseDisposition = .allow
expectedContentLength = response.expectedContentLength
if let dataTaskDidReceiveResponse = dataTaskDidReceiveResponse {
disposition = dataTaskDidReceiveResponse(session, dataTask, response)
}
completionHandler(disposition)
}
当收到服务端的响应后，该方法被触发。在这个函数中，我们能够获取到和数据相关的一些参数，大家可以想象成响应头。Alamofire中给出了一个函数dataTaskDidReceiveResponse，我们可以利用这个函数控制是不是要继续获取数据，默认是.allow。
我们看第二个函数：
func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
didBecome downloadTask: URLSessionDownloadTask)
{
dataTaskDidBecomeDownloadTask?(session, dataTask, downloadTask)
}
在上边的disposition配置中，disposition的类型是URLSession.ResponseDisposition，我们看看这个枚举
public enum ResponseDisposition : Int {
case cancel /* Cancel the load, this is the same as -[task cancel] */
case allow /* Allow the load to continue */
case becomeDownload /* Turn this request into a download */
@available(iOS 9.0, *)
case becomeStream /* Turn this task into a stream task */
}
当选择了becomeDownload后，就会触发上边的第二个函数，在函数中会提供一个新的downloadTask。这就给我们一个把dataTask转换成downloadTask的机会
那么我们把dataTask转换成downloadTask究竟有什么用呢？我想到了一个使用场景，假如给定一个URL，返回的数据是Data，其实我想把这些数据下载下来，那么就可以使用上边的这种技术了。举个例子，https://baidu.com打开这个url会直接显示网页，使用上边的技术，打开这个url会直接下载网页。我并没有验证上边的想法
我们继续看第三个函数：
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) }
}
}
}
这个方法算是核心方法，Alamofire把数据放入对象中，
我们看第四个函数：
func urlSession(
_ session: URLSession,
dataTask: URLSessionDataTask,
willCacheResponse proposedResponse: CachedURLResponse,
completionHandler: @escaping (CachedURLResponse?) -> Void)
{
var cachedResponse: CachedURLResponse? = proposedResponse
if let dataTaskWillCacheResponse = dataTaskWillCacheResponse {
cachedResponse = dataTaskWillCacheResponse(session, dataTask, proposedResponse)
}
completionHandler(cachedResponse)
}
其实，往往这样的函数才是我们应该注意的，最常见的接受响应，处理数据，请求完成都是我们很熟悉的方法，因此更应该多多注意这些不太熟悉的方法。
该函数用于处理是否需要缓存响应，Alamofire默认是缓存这些response的，但是每次发请求，它不会再缓存中读取。
DownloadTaskDelegate
DownloadTaskDelegate继承自TaskDelegate,实现了URLSessionDownloadDelegate协议。因此下边我们也会讲解URLSessionDownloadDelegate协议的方法。我们还是先看这里边的属性：
// MARK: Properties
var downloadTask: URLSessionDownloadTask { return task as! URLSessionDownloadTask }
var progress: Progress
var progressHandler: (closure: Request.ProgressHandler, queue: DispatchQueue)?
var resumeData: Data?
override var data: Data? { return resumeData }
var destination: DownloadRequest.DownloadFileDestination?
var temporaryURL: URL?
var destinationURL: URL?
var fileURL: URL? { return destination != nil ? destinationURL : temporaryURL }
这些属性中有和上边介绍的属性重复的部分，我们只对不重复的部分给出说明：
(1)downloadTask 和URLSessionDownloadDelegate相对应的URLSessionDownloadTask
(2)resumeData 在上边我们提到过，当请求完成后，如果error不为nil，如果是DownloadTaskDelegate，就会给这个属性赋值
(3)data 返回resumeData
(4)destination 通过这个函数可以自定义文件保存目录和保存方式，这个保存方式分两种，为URl创建文件夹，删除已经下载且存在的文件，这个会在后续的文章中提到
(5)temporaryURL 临时的URL
(6)destinationURL 数据存储URL
(7)fileURL返回文件的路径，如果destination不为nil，就返回destinationURL，否则返回temporaryURL
生命周期：
// MARK: Lifecycle
override init(task: URLSessionTask?) {
progress = Progress(totalUnitCount: 0)
super.init(task: task)
}
override func reset() {
super.reset()
progress = Progress(totalUnitCount: 0)
resumeData = nil
}
和下载相关的代理函数有三个：
var downloadTaskDidFinishDownloadingToURL: ((URLSession, URLSessionDownloadTask, URL) -> URL)?
var downloadTaskDidWriteData: ((URLSession, URLSessionDownloadTask, Int64, Int64, Int64) -> Void)?
var downloadTaskDidResumeAtOffset: ((URLSession, URLSessionDownloadTask, Int64, Int64) -> Void)?
我们先看看第一个函数：
func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didFinishDownloadingTo location: URL)
{
temporaryURL = location
guard
let destination = destination,
let response = downloadTask.response as? HTTPURLResponse
else { return }
let result = destination(location, response)
let destinationURL = result.destinationURL
let options = result.options
self.destinationURL = destinationURL
/// 说明在编码过程中，对于存在可能出现错误的地方，一定要做error处理
do {
if options.contains(.removePreviousFile), FileManager.default.fileExists(atPath: destinationURL.path) {
try FileManager.default.removeItem(at: destinationURL)
}
if options.contains(.createIntermediateDirectories) {
let directory = destinationURL.deletingLastPathComponent()
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
}
try FileManager.default.moveItem(at: location, to: destinationURL)
} catch {
self.error = error
}
}
对于这样的代理方法，我们首先要做的就是弄明白在什么情况下它会被触发。当数据下载完成后，该函数被触发。系统会把数据下载到一个临时的locationURL的地方，我们就是通过这个URL拿到数据的。上边函数内的代码主要是把数据复制到目标路径中。
对于这样的代理方法，我们首先要做的就是弄明白在什么情况下它会被触发。当数据下载完成后，该函数被触发。系统会把数据下载到一个临时的locationURL的地方，我们就是通过这个URL拿到数据的。上边函数内的代码主要是把数据复制到目标路径中。
我们来看第二个函数：
func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didWriteData bytesWritten: Int64,
totalBytesWritten: Int64,
totalBytesExpectedToWrite: Int64)
{
if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
if let downloadTaskDidWriteData = downloadTaskDidWriteData {
downloadTaskDidWriteData(
session,
downloadTask,
bytesWritten,
totalBytesWritten,
totalBytesExpectedToWrite
)
} else {
progress.totalUnitCount = totalBytesExpectedToWrite
progress.completedUnitCount = totalBytesWritten
if let progressHandler = progressHandler {
progressHandler.queue.async { progressHandler.closure(self.progress) }
}
}
}
该代理方法在数据下载过程中被触发，主要的作用就是提供下载进度。这个比较简单，我们看看第三个函数：
func urlSession(
_ session: URLSession,
downloadTask: URLSessionDownloadTask,
didResumeAtOffset fileOffset: Int64,
expectedTotalBytes: Int64)
{
if let downloadTaskDidResumeAtOffset = downloadTaskDidResumeAtOffset {
downloadTaskDidResumeAtOffset(session, downloadTask, fileOffset, expectedTotalBytes)
} else {
progress.totalUnitCount = expectedTotalBytes
progress.completedUnitCount = fileOffset
}
}
是这样的，如果一个下载的task是可以恢复的，那么当下载被取消或者失败后，系统会返回一个resumeData对象，这个对象包含了一些跟这个下载task相关的一些信息，有了它就能重新创建下载task，创建方法有两个：downloadTask(withResumeData:)和downloadTask(withResumeData:completionHandler:),当task开始后，上边的代理方法就会被触发。
UploadTaskDelegate
UploadTaskDelegate继承自DataTaskDelegate。对于上传数据来说最麻烦的就是多表单数据的上传，这个我们会在后续的MultipartFormData.swift给出详细的解释。
我们先看看它的属性有哪些？
var uploadTask: URLSessionUploadTask { return task as! URLSessionUploadTask }
var uploadProgress: Progress
var uploadProgressHandler: (closure: Request.ProgressHandler, queue: DispatchQueue)?
这些和上边出现的内容有重叠，在这里就不多做解释了，我们再看看生命周期：
// MARK: Lifecycle
override init(task: URLSessionTask?) {
uploadProgress = Progress(totalUnitCount: 0)
super.init(task: task)
}
override func reset() {
super.reset()
uploadProgress = Progress(totalUnitCount: 0)
}
也没什么好说的，再看看函数：
// MARK: URLSessionTaskDelegate
var taskDidSendBodyData: ((URLSession, URLSessionTask, Int64, Int64, Int64) -> Void)?
func URLSession(
_ session: URLSession,
task: URLSessionTask,
didSendBodyData bytesSent: Int64,
totalBytesSent: Int64,
totalBytesExpectedToSend: Int64)
{
if initialResponseTime == nil { initialResponseTime = CFAbsoluteTimeGetCurrent() }
if let taskDidSendBodyData = taskDidSendBodyData {
taskDidSendBodyData(session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)
} else {
uploadProgress.totalUnitCount = totalBytesExpectedToSend
uploadProgress.completedUnitCount = totalBytesSent
if let uploadProgressHandler = uploadProgressHandler {
uploadProgressHandler.queue.async { uploadProgressHandler.closure(self.uploadProgress) }
}
}
}
该函数主要目的是提供上传的进度，在Alamofire中，上传数据用的是stream，这个会在后续文章中给出详细的解释。
