NSURLSession最全攻略

时间  2020-07-07 标签 nsurlsession 全 攻略
该文章属于<简书 — 刘小壮>原创，转载请注明：

<简书 — 刘小壮>数据库

封面图

NSURLSession

NSURLSession在iOS7中推出，NSURLSession的推出旨在替换以前的NSURLConnection，NSURLSession的使用相对于以前的NSURLConnection更简单，并且不用处理Runloop相关的东西。后端

2015年RFC 7540标准发布了http 2.0版本，http 2.0版本中包含不少新的特性，在传输速度上也有很明显的提高。NSURLSession从iOS9.0开始，对http 2.0提供了支持。数组

NSURLSession由三部分构成：缓存

  • NSURLSession：请求会话对象，能够用系统提供的单例对象，也能够本身建立。
  • NSURLSessionConfiguration：对session会话进行配置，通常都采用default。
  • NSURLSessionTask：负责执行具体请求的task，由session建立。

NSURLSession有三种方式建立：安全

sharedSession

系统维护的一个单例对象，能够和其余使用这个session的task共享链接和请求信息。服务器

sessionWithConfiguration:

在NSURLSession初始化时传入一个NSURLSessionConfiguration，这样能够自定义请求头、cookie等信息。cookie

sessionWithConfiguration:delegate:delegateQueue:

若是想更好的控制请求过程以及回调线程，须要上面的方法进行初始化操做，并传入delegate来设置回调对象和回调的线程。网络

经过NSURLSession发起一个网络请求也比较简单。session

  1. 建立一个NSURLSessionConfiguration配置请求。
  2. 经过Configuration建立NSURLSession对象。
  3. 经过session对象发起网络请求，并获取task对象。
  4. 调用[task resume]方法发起网络请求。
NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
NSURLSession *session = [NSURLSession sessionWithConfiguration:config
                                                      delegate:self
                                                 delegateQueue:[NSOperationQueue mainQueue]];
NSURLSessionDataTask *task = [session dataTaskWithURL:[NSURL URLWithString:@"http://www.baidu.com"]];
[task resume];

NSURLSessionTask

经过NSURLSession发起的每一个请求，都会被封装为一个NSURLSessionTask任务，但通常不会直接是NSURLSessionTask类，而是基于不一样任务类型，被封装为其对应的子类。并发

  • NSURLSessionDataTask：处理普通的Get、Post请求。
  • NSURLSessionUploadTask：处理上传请求，能够传入对应的上传文件或路径。
  • NSURLSessionDownloadTask：处理下载地址，提供断点续传功能的cancel方法。

主要方法都定义在父类NSURLSessionTask中，下面是一些关键方法或属性。

currentRequest
当前正在执行的任务，通常和originalRequest是同样的，除非发生重定向才会有所区别。
originalRequest
主要用于重定向操做，用来记录重定向前的请求。
taskIdentifier
当前session下，task的惟一标示，多个session之间可能存在相同的标识。
priority
task中能够设置优先级，但这个属性并不表明请求的优先级，而是一个标示。官方已经说明，NSURLSession并无提供API能够改变请求的优先级。
state
当前任务的状态，能够经过KVO的方式监听状态的改变。
- resume
开始或继续请求，建立后的task默认是挂起的，须要手动调用resume才能够开始请求。
- suspend
挂起当前请求。主要是下载请求用的多一些，普通请求挂起后都会从新开始请求。下载请求挂起后，只要不超过NSURLRequest设置的timeout时间，调用resume就是继续请求。
- cancel
取消当前请求。任务会被标记为取消，并在将来某个时间调用URLSession:task:didCompleteWithError:方法。

NSURLSession提供有普通建立task的方式，建立后能够经过重写代理方法，获取对应的回调和参数。这种方式对于请求过程比较好控制。

- (NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request;
- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request fromFile:(NSURL *)fileURL;
- (NSURLSessionDownloadTask *)downloadTaskWithRequest:(NSURLRequest *)request;

除此以外，NSURLSession也提供了block的方式建立task，建立方式简单如AFN，直接传入URL或NSURLRequest，便可直接在block中接收返回数据。和普通建立方式同样，block的建立方式建立后默认也是suspend的状态，须要调用resume开始任务。

completionHandler和delegate是互斥的，completionHandler的优先级大于delegate。相对于普通建立方法，block方式更偏向于面向结果的建立，能够直接在completionHandler中获取返回结果，但不能控制请求过程。

- (NSURLSessionDataTask *)dataTaskWithURL:(NSURL *)url completionHandler:(void (^)(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error))completionHandler;
- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request fromData:(nullable NSData *)bodyData completionHandler:(void (^)(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error))completionHandler;
- (NSURLSessionDownloadTask *)downloadTaskWithURL:(NSURL *)url completionHandler:(void (^)(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error))completionHandler;

能够经过下面的两个方法，获取当前session对应的全部task，方法区别在于回调的参数不一样。以getTasksWithCompletionHandler为例，在AFN中的应用是用来获取当前session的task，并将AFURLSessionManagerTaskDelegate的回调都置为nil，以防止崩溃。

- (void)getTasksWithCompletionHandler:(void (^)(NSArray<NSURLSessionDataTask *> *dataTasks, NSArray<NSURLSessionUploadTask *> *uploadTasks, NSArray<NSURLSessionDownloadTask *> *downloadTasks))completionHandler;

- (void)getAllTasksWithCompletionHandler:(void (^)(NSArray<__kindof NSURLSessionTask *> *tasks))completionHandler);

delegateQueue

在初始化NSURLSession时能够指定线程，若是不指定线程，则completionHandler和delegate的回调方法，都会在子线程中执行。

若是初始化NSURLSession时指定了delegateQueue，则回调会在指定的队列中执行，若是指定的是mainQueue，则回调在主线程中执行，这样就避免了切换线程的问题。

[NSURLSession sessionWithConfiguration:config delegate:self delegateQueue:nil];

delegate

对于NSURLSession的代理方法这里就不详细列举了，方法命名遵循苹果一向见名知意的原则，用起来很简单。这里介绍一下NSURLSession的代理继承结构。

代理继承关系

NSURLSession中定义了一系列代理，并遵循上面的继承关系。根据继承关系和代理方法的声明，若是执行某项任务，只须要遵照其中的某个代理便可。

例如执行上传或普通Post请求，则遵照NSURLSessionDataDelegate，执行下载任务则遵循NSURLSessionDownloadDelegate，父级代理定义的都是公共方法。

请求重定向

HTTP协议中定义了例如301等重定向状态码，经过下面的代理方法，能够处理重定向任务。发生重定向时能够根据response建立一个新的request，也能够直接用系统生成的request，并在completionHandler回调中传入，若是想终止此次重定向，在completionHandler传入nil便可。

- (void)URLSession:(NSURLSession *)session
              task:(NSURLSessionTask *)task
willPerformHTTPRedirection:(NSHTTPURLResponse *)response
        newRequest:(NSURLRequest *)request
 completionHandler:(void (^)(NSURLRequest *))completionHandler
{
    NSURLRequest *redirectRequest = request;

    if (self.taskWillPerformHTTPRedirection) {
        redirectRequest = self.taskWillPerformHTTPRedirection(session, task, response, request);
    }

    if (completionHandler) {
        completionHandler(redirectRequest);
    }
}

NSURLSessionConfiguration

建立方式

NSURLSessionConfiguration负责对NSURLSession初始化时进行配置，经过NSURLSessionConfiguration能够设置请求的Cookie、密钥、缓存、请求头等参数，将网络请求的一些配置参数从NSURLSession中分离出来。

NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
NSURLSession *session = [NSURLSession sessionWithConfiguration:config
                                                      delegate:self
                                                 delegateQueue:[NSOperationQueue mainQueue]];

NSURLSessionConfiguration提供三种初始化方法，下面是请求的方法的一些解释。

@property (class, readonly, strong) NSURLSessionConfiguration *defaultSessionConfiguration;

NSURLSessionConfiguration提供defaultSessionConfiguration的方式建立，但这并非单例方法，而是类方法，建立的是不一样对象。经过这种方式建立的configuration，并不会共享cookie、cache、密钥等，而是不一样configuration都须要单独设置。

这块网上不少人理解都是错的，并无真的在项目里使用或者没有留意过，如和其余人有出入，以我为准。

@property (class, readonly, strong) NSURLSessionConfiguration *ephemeralSessionConfiguration;

建立临时的configuration，经过这种方式建立的对象，和普通的对象主要区别在于URLCache、URLCredentialStorage、HTTPCookieStorage上面。一样的，Ephemeral也不是单例方法，而只是类方法。

URLCredentialStorage
Ephemeral <__NSCFMemoryURLCredentialStorage: 0x600001bc8320>

HTTPCookieStorage
Ephemeral <NSHTTPCookieStorage cookies count:0>

若是对Ephemeral方式建立的config进行打印的话，能够看到变量类型明显区别于其余类型，而且在打印信息前面会有Ephemeral的标示。经过Ephemeral的方式建立的config，不会产生持久化信息，能够很好保护请求的数据安全性。

+ (NSURLSessionConfiguration *)backgroundSessionConfigurationWithIdentifier:(NSString *)identifier;

identifier方式通常用于恢复以前的任务，主要用于下载。若是一个下载任务正在进行中，程序被kill调，能够在程序退出以前保存identifier。下次进入程序后经过identifier恢复以前的任务，系统会将NSURLSession及NSURLSessionConfiguration和以前的下载任务进行关联，并继续以前的任务。

timeout

timeoutIntervalForRequest

设置session请求间的超时时间，这个超时时间并非请求从开始到结束的时间，而是两个数据包之间的时间间隔。当任意请求返回后这个值将会被重置，若是在超时时间内未返回则超时。单位为秒，默认为60秒。

timeoutIntervalForResource

资源超时时间，通常用于上传或下载任务，在上传或下载任务开始后计时，若是到达时间任务未结束，则删除资源文件。单位为秒，默认时间是七天。

资源共享

若是是相同的NSURLSessionConfiguration对象，会共享请求头、缓存、cookie、Credential，经过Configuration建立的NSURLSession，也会拥有对应的请求信息。

@property (nullable, copy) NSDictionary *HTTPAdditionalHeaders;

公共请求头，默认是空的，设置后全部经Confuguration配置的NSURLSession，请求头都会带有设置的信息。

@property (nullable, retain) NSHTTPCookieStorage *HTTPCookieStorage;

HTTP请求的Cookie管理器。若是是经过sharedSession或backgroundConfiguration建立的NSURLSession，默认使用sharedHTTPCookieStorage的Cookie数据。若是不想使用Cookie，则直接设置为nil便可，也能够手动设置为本身的CookieStorage。

@property (nullable, retain) NSURLCredentialStorage *URLCredentialStorage;

证书管理器。若是是经过sharedSession或backgroundConfiguration建立的NSURLSession，默认使用sharedCredentialStorage的证书。若是不想使用证书，能够直接设置为nil，也能够本身建立证书管理器。

@property (nullable, retain) NSURLCache *URLCache;

请求缓存，若是不手动设置的话为nil，对于NSURLCache这个类我没有研究过，不太了解。

缓存处理

在NSURLRequest中能够设置cachePolicy请求缓存策略，这里不对具体值作详细描述，默认值为NSURLRequestUseProtocolCachePolicy使用缓存。

NSURLSessionConfiguration能够设置处理缓存的对象，咱们能够手动设置自定义的缓存对象，若是不设置的话，默认使用系统的sharedURLCache单例缓存对象。通过configuration建立的NSURLSession发出的请求，NSURLRequest都会使用这个NSURLCache来处理缓存。

@property (nullable, retain) NSURLCache *URLCache;

NSURLCache提供了Memory和Disk的缓存，在建立时须要为其分别指定Memory和Disk的大小，以及存储的文件位置。使用NSURLCache不用考虑磁盘空间不够，或手动管理内存空间的问题，若是发生内存警告系统会自动清理内存空间。可是NSURLCache提供的功能很是有限，项目中通常不多直接使用它来处理缓存数据，仍是用数据库比较多。

[[NSURLCache alloc] initWithMemoryCapacity:30 * 1024 * 1024 
                              diskCapacity:30 * 1024 * 1024 
                              directoryURL:[NSURL URLWithString:filePath]];

使用NSURLCache还有一个好处，就是能够由服务端来设置资源过时时间，在请求服务端后，服务端会返回Cache-Control来讲明文件的过时时间。NSURLCache会根据NSURLResponse来自动完成过时时间的设置。

最大链接数

限制NSURLSession的最大链接数，经过此方法建立的NSURLSession和服务端的最大链接数量不会超出这里设置的数量。苹果为咱们设置的iOS端默认为4，Mac端默认为6。

@property NSInteger HTTPMaximumConnectionsPerHost;

链接复用

HTTP是基于传输层协议TCP的，经过TCP发送网络请求都须要先进行三次握手，创建网络请求后再发送数据，请求结束时再经历四次挥手。HTTP1.0开始支持keep-alive，keep-alive能够保持已经创建的连接，若是是相同的域名，在请求链接创建后，后面的请求不会马上断开，而是复用现有的链接。从HTTP1.1开始默认开启keep-alive。

请求是在请求头中设置下面的参数，服务器若是支持keep-alive的话，响应客户端请求时，也会在响应头中加上相同的字段。

Connection: Keep-Alive

若是想断开keep-alive，能够在请求头中加上下面的字段，但通常不推荐这么作。

Connection: Close

若是经过NSURLSession来进行网络请求的话，须要使用同一个NSURLSession对象，若是建立新的session对象则不能复用以前的连接。keep-alive能够保持请求的链接，苹果容许在iOS上最大保持有4个链接，Mac则是6个链接。

pipeline

pipeline

在HTTP1.1中，基于keep-alive，还能够将请求进行管线化。和相同后端服务，TCP层创建的连接，通常都须要前一个请求返回后，后面的请求再发出。但pipeline就能够不依赖以前请求的响应，而发出后面的请求。

pipeline依赖客户端和服务器都有实现，服务端收到客户端的请求后，要按照先进先出的顺序进行任务处理和响应。pipeline依然存在以前非pipeline的问题，就是前面的请求若是出现问题，会阻塞当前链接影响后面的请求。

pipeline对于请求大文件并无提高做用，只是对于普通请求速度有提高。在NSURLSessionConfiguration中能够设置HTTPShouldUsePipelining为YES，开启管线化，此属性默认为NO。

NSURLSessionTaskMetrics

在平常开发过程当中，常常遇到页面加载太慢的问题，这很大一部分缘由都是由于网络致使的。因此，查找网络耗时的缘由并解决，就是一个很重要的任务了。苹果对于网络检查提供了NSURLSessionTaskMetrics类来进行检查，NSURLSessionTaskMetrics是对应NSURLSessionTaskDelegate的，每一个task结束时都会回调下面的方法，而且能够得到一个metrics对象。

- (void)URLSession:(NSURLSession *)session 
              task:(NSURLSessionTask *)task 
didFinishCollectingMetrics:(NSURLSessionTaskMetrics *)metrics;

NSURLSessionTaskMetrics能够很好的帮助咱们分析网络请求的过程，以找到耗时缘由。除了这个类以外，NSURLSessionTaskTransactionMetrics类中承载了更详细的数据。

@property (copy, readonly) NSArray<NSURLSessionTaskTransactionMetrics *> *transactionMetrics;

transactionMetrics数组中每个元素都对应着当前task的一个请求，通常数组中只会有一个元素，若是发生重定向等状况，可能会存在多个元素。

@property (copy, readonly) NSDateInterval *taskInterval;

taskInterval记录了当前task从开始请求到最后完成的总耗时，NSDateInterval中包含了startDate、endDate和duration耗时时间。

@property (assign, readonly) NSUInteger redirectCount;

redirectCount记录了重定向次数，在进行下载请求时通常都会进行重定向，来保证下载任务能由后端最合适的节点来处理。

NSURLSessionTaskTransactionMetrics

NSURLSessionTaskTransactionMetrics中的属性都是用来作统计的，功能都是记录某个值，并无逻辑上的意义。因此这里就对一些主要的属性作一下解释，基本涵盖了大部分属性，其余就无论了。

这张图是我从网上扒下来的，标示了NSURLSessionTaskTransactionMetrics的属性在请求过程当中处于什么位置。

请求耗时细节

// 请求对象
@property (copy, readonly) NSURLRequest *request;
// 响应对象，请求失败可能会为nil
@property (nullable, copy, readonly) NSURLResponse *response;
// 请求开始时间
@property (nullable, copy, readonly) NSDate *fetchStartDate;
// DNS解析开始时间
@property (nullable, copy, readonly) NSDate *domainLookupStartDate;
// DNS解析结束时间，若是解析失败可能为nil
@property (nullable, copy, readonly) NSDate *domainLookupEndDate;
// 开始创建TCP链接时间
@property (nullable, copy, readonly) NSDate *connectStartDate;
// 结束创建TCP链接时间
@property (nullable, copy, readonly) NSDate *connectEndDate;
// 开始TLS握手时间
@property (nullable, copy, readonly) NSDate *secureConnectionStartDate;
// 结束TLS握手时间
@property (nullable, copy, readonly) NSDate *secureConnectionEndDate;
// 开始传输请求数据时间
@property (nullable, copy, readonly) NSDate *requestStartDate;
// 结束传输请求数据时间
@property (nullable, copy, readonly) NSDate *requestEndDate;
// 接收到服务端响应数据时间
@property (nullable, copy, readonly) NSDate *responseStartDate;
// 服务端响应数据传输完成时间
@property (nullable, copy, readonly) NSDate *responseEndDate;
// 网络协议，例如http/1.1
@property (nullable, copy, readonly) NSString *networkProtocolName;
// 请求是否使用代理
@property (assign, readonly, getter=isProxyConnection) BOOL proxyConnection;
// 是否复用已有链接
@property (assign, readonly, getter=isReusedConnection) BOOL reusedConnection;
// 资源标识符，表示请求是从Cache、Push、Network哪一种类型加载的
@property (assign, readonly) NSURLSessionTaskMetricsResourceFetchType resourceFetchType;
// 本地IP
@property (nullable, copy, readonly) NSString *localAddress;
// 本地端口号
@property (nullable, copy, readonly) NSNumber *localPort;
// 远端IP
@property (nullable, copy, readonly) NSString *remoteAddress;
// 远端端口号
@property (nullable, copy, readonly) NSNumber *remotePort;
// TLS协议版本，若是是http则是0x0000
@property (nullable, copy, readonly) NSNumber *negotiatedTLSProtocolVersion;
// 是否使用蜂窝数据
@property (readonly, getter=isCellular) BOOL cellular;

下面是我发起一个http的下载请求，统计获得的数据。设备是Xcode模拟器，网络环境是WiFi。

(Request) <NSURLRequest: 0x600000c80380> { URL: http://vfx.mtime.cn/Video/2017/03/31/mp4/170331093811717750.mp4 }
(Response) <NSHTTPURLResponse: 0x600000ed9420> { URL: http://vfx.mtime.cn/Video/2017/03/31/mp4/170331093811717750.mp4 } { Status Code: 200, Headers {
    "Accept-Ranges" =     (
        bytes
    );
    Age =     (
        1063663
    );
    "Ali-Swift-Global-Savetime" =     (
        1575358696
    );
    Connection =     (
        "keep-alive"
    );
    "Content-Length" =     (
        20472584
    );
    "Content-Md5" =     (
        "YM+JxIH9oLH6l1+jHN9pmQ=="
    );
    "Content-Type" =     (
        "video/mp4"
    );
    Date =     (
        "Tue, 03 Dec 2019 07:38:16 GMT"
    );
    EagleId =     (
        dbee142415764223598843838e
    );
    Etag =     (
        "\"60CF89C481FDA0B1FA975FA31CDF6999\""
    );
    "Last-Modified" =     (
        "Fri, 31 Mar 2017 01:41:36 GMT"
    );
    Server =     (
        Tengine
    );
    "Timing-Allow-Origin" =     (
        "*"
    );
    Via =     (
        "cache39.l2et2[0,200-0,H], cache6.l2et2[3,0], cache16.cn548[0,200-0,H], cache16.cn548[1,0]"
    );
    "X-Cache" =     (
        "HIT TCP_MEM_HIT dirn:-2:-2"
    );
    "X-M-Log" =     (
        "QNM:xs451;QNM3:71"
    );
    "X-M-Reqid" =     (
        "m0AAAP__UChjzNwV"
    );
    "X-Oss-Hash-Crc64ecma" =     (
        12355898484621380721
    );
    "X-Oss-Object-Type" =     (
        Normal
    );
    "X-Oss-Request-Id" =     (
        5DE20106F3150D38305CE159
    );
    "X-Oss-Server-Time" =     (
        130
    );
    "X-Oss-Storage-Class" =     (
        Standard
    );
    "X-Qnm-Cache" =     (
        Hit
    );
    "X-Swift-CacheTime" =     (
        2592000
    );
    "X-Swift-SaveTime" =     (
        "Sun, 15 Dec 2019 15:05:37 GMT"
    );
} }
(Fetch Start) 2019-12-15 15:05:59 +0000
(Domain Lookup Start) 2019-12-15 15:05:59 +0000
(Domain Lookup End) 2019-12-15 15:05:59 +0000
(Connect Start) 2019-12-15 15:05:59 +0000
(Secure Connection Start) (null)
(Secure Connection End) (null)
(Connect End) 2019-12-15 15:05:59 +0000
(Request Start) 2019-12-15 15:05:59 +0000
(Request End) 2019-12-15 15:05:59 +0000
(Response Start) 2019-12-15 15:05:59 +0000
(Response End) 2019-12-15 15:06:04 +0000
(Protocol Name) http/1.1
(Proxy Connection) NO
(Reused Connection) NO
(Fetch Type) Network Load
(Request Header Bytes) 235
(Request Body Transfer Bytes) 0
(Request Body Bytes) 0
(Response Header Bytes) 866
(Response Body Transfer Bytes) 20472584
(Response Body Bytes) 20472584
(Local Address) 192.168.1.105
(Local Port) 63379
(Remote Address) 219.238.20.101
(Remote Port) 80
(TLS Protocol Version) 0x0000
(TLS Cipher Suite) 0x0000
(Cellular) NO
(Expensive) NO
(Constrained) NO
(Multipath) NO

FAQ

NSURLSession的delegate为何是强引用？

在初始化NSURLSession对象并设置代理后，代理对象将会被强引用。根据苹果官方的注释来看，这个强持有并不会一直存在，而是在调用URLSession:didBecomeInvalidWithError:方法后，会将delegate释放。

经过调用NSURLSession的invalidateAndCancel或finishTasksAndInvalidate方法，便可将强引用断开并执行didBecomeInvalidWithError:代理方法，执行完成后session就会无效不可使用。也就是只有在session无效时，才能够解除强引用的关系。

有时候为了保证链接复用等问题，通常不会轻易将session会话invalid，因此最好不要直接使用NSURLSession，而是要对其进行一次二次封装，使用AFN3.0的缘由之一也在于此。

NSURLSession的上传下载

文件上传

表单上传

客户端有时候须要给服务端上传大文件，进行大文件确定不能全都加载到内存里，一口气都传给服务器。进行大文件上传时，通常都会对须要上传的文件进行分片，分片后逐个文件进行上传。须要注意的是，分片上传和断点续传并非同一个概念，上传并不支持断点续传。

进行分片上传时，须要对本地文件进行读取，咱们使用NSFileHandle来进行文件读取。NSFileHandle提供了一个偏移量的功能，咱们能够将handle的当前读取位置seek到上次读取的位置，并设置本次读取长度，读取的文件就是咱们指定文件的字节。

- (NSData *)readNextBuffer {
    if (self.maxSegment <= self.currentIndex) {
        return nil;
    }
    
    if(!self.fileHandler){
        NSString *filePath = [self uploadFile];
        NSFileHandle *fileHandle = [NSFileHandle fileHandleForReadingAtPath:filePath];
        self.fileHandler = fileHandle;
    }
    [self.fileHandler seekToFileOffset:(self.currentIndex) * self.segmentSize];
    NSData *data = [self.fileHandler readDataOfLength:self.segmentSize];
    return data;
}

上传文件如今主流的方式，都是采起表单上传的方式，也就是multipart/from-data，AFNetworking对表单上传也有颇有的支持。表单上传须要遵循下面的格式进行上传，boundary是一个16进制字符串，能够是任何且惟一的。boundary的功能用来进行字段分割，区分开不一样的参数部分。

multipart/from-data规范定义在rfc2388，详细字段能够看一下规范。

--boundary
 Content-Disposition: form-data; name="参数名"
 参数值
 --boundary
 Content-Disposition:form-data;name=”表单控件名”;filename=”上传文件名”
 Content-Type:mime type
 要上传文件二进制数据
 --boundary--

拼接上传文件基本上能够分为下面三部分，上传参数、上传信息、上传文件。而且经过UTF-8格式进行编码，服务端也采用相同的解码方式，则能够得到上传文件和信息。须要注意的是，换行符数量是固定的，这都是固定的协议格式，不要多或者少，会致使服务端解析失败。

- (NSData *)writeMultipartFormData:(NSData *)data 
                        parameters:(NSDictionary *)parameters {
    if (data.length == 0) {
        return nil;
    }
    
    NSMutableData *formData = [NSMutableData data];
    NSData *lineData = [@"\r\n" dataUsingEncoding:NSUTF8StringEncoding];
    NSData *boundary = [kBoundary dataUsingEncoding:NSUTF8StringEncoding];
    
    // 拼接上传参数
    [parameters enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
        [formData appendData:boundary];
        [formData appendData:lineData];
        NSString *thisFieldString = [NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"\r\n\r\n%@", key, obj];
        [formData appendData:[thisFieldString dataUsingEncoding:NSUTF8StringEncoding]];
        [formData appendData:lineData];
    }];
    
    // 拼接上传信息
    [formData appendData:boundary];
    [formData appendData:lineData];
    NSString *thisFieldString = [NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"; filename=\"%@\"\r\nContent-Type: %@", @"name", @"filename", @"mimetype"];
    [formData appendData:[thisFieldString dataUsingEncoding:NSUTF8StringEncoding]];
    [formData appendData:lineData];
    [formData appendData:lineData];
    
    // 拼接上传文件
    [formData appendData:data];
    [formData appendData:lineData];
    [formData appendData: [[NSString stringWithFormat:@"--%@--\r\n", kBoundary] dataUsingEncoding:NSUTF8StringEncoding]];
    
    return formData;
}

除此以外，表单提交还须要设置请求头的Content-Type和Content-Length，不然会致使请求失败。其中Content-Length并非强制要求的，要看后端的具体支持状况。

设置请求头时，必定要加上boundary，这个boundary和拼接上传文件的boundary须要是同一个。服务端从请求头拿到boundary，来解析上传文件。

NSString *headerField = [NSString stringWithFormat:@"multipart/form-data; charset=utf-8; boundary=%@", kBoundary];
[request setValue:headerField forHTTPHeaderField:@"Content-Type"];

NSUInteger size = [[[NSFileManager defaultManager] attributesOfItemAtPath:uploadPath error:nil] fileSize];
headerField = [NSString stringWithFormat:@"%lu", size];
[request setValue:headerField forHTTPHeaderField:@"Content-Length"];

随后咱们经过下面的代码建立NSURLSessionUploadTask，并调用resume发起请求，实现对应的代理回调便可。

// 发起网络请求
NSURLSessionUploadTask *uploadTask = [self.backgroundSession uploadTaskWithRequest:request fromData:fromData];
[uploadTask resume];
    
// 请求完成后调用，不管成功仍是失败
- (void)URLSession:(NSURLSession *)session
              task:(NSURLSessionTask *)task
didCompleteWithError:(NSError *)error {
    
}

// 更新上传进度，会回调屡次
- (void)URLSession:(NSURLSession *)session
              task:(NSURLSessionTask *)task
   didSendBodyData:(int64_t)bytesSent
    totalBytesSent:(int64_t)totalBytesSent
totalBytesExpectedToSend:(int64_t)totalBytesExpectedToSend {
    
}

// 数据接收完成回调
- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
    didReceiveData:(NSData *)data {
    
}

// 处理后台上传任务，当前session的上传任务结束后会回调此方法。
- (void)URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session {
    
}

可是，若是你认为这就完成一个上传功能了，too young too simple~

后台上传

若是经过fromData的方式进行上传，并不支持后台上传。若是想实现后台上传，须要经过fromFile的方式上传文件。不止如此，fromData还有其余坑。

- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request fromData:(NSData *)bodyData;
- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request fromFile:(NSURL *)fileURL;

内存占用

咱们发现经过fromData:的方式上传文件，内存涨上去以后一直不能降下来，不管是直接使用NSURLSession仍是AFNetworking，都是这样的。小文件还好，不是很明显，若是是几百MB的大文件很明显就会有一个内存峰值，并且涨上去就不会降下来。WTF？

上传有两种方式上传，若是咱们把fromData:的上传改成fromFile:，就能够解决内存不降低的问题。因此，咱们能够把fromData:的上传方式，理解为UIImage的imageNamed的方法，上传后NSData文件会保存在内存中，不会被回收。而fromFile:的方式是从本地加载文件，而且上传完成后能够被回收。并且若是想支持后台上传，就必须用fromFile:的方式进行上传。

OK，那找到问题咱们就开干，改变以前的上传逻辑，改成fromFile:的方式上传。

// 将分片写入到本地
NSString *filePath = [NSString stringWithFormat:@"%@/%ld", [self segmentDocumentPath], currentIndex];
BOOL write = [formData writeToFile:filePath atomically:YES];

// 建立分片文件夹
- (NSString *)segmentDocumentPath {
    NSString *documentName = [fileName md5String];
    NSString *filePath = [[SVPUploadCompressor compressorPath] stringByAppendingPathComponent:documentName];
    BOOL needCreateDirectory = YES;
    BOOL isDirectory = NO;
    if ([[NSFileManager defaultManager] fileExistsAtPath:filePath isDirectory:&isDirectory]) {
        if (isDirectory) {
            needCreateDirectory = NO;
        } else {
            [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
        }
    }
    
    if (needCreateDirectory) {
        [[NSFileManager defaultManager] createDirectoryAtPath:filePath
                                  withIntermediateDirectories:YES
                                                   attributes:nil
                                                        error:nil];
    }
    return filePath;
}

由于要经过fromFile:方法传一个本地分片的路径进去，因此须要预先对文件进行分片，并保存在本地。在分片的同时，还须要拼接boundary信息。

因此咱们在上传任务开始前，先对文件进行分片并拼接信息，而后将分片文件写入到本地。为了方便管理，咱们基于具备惟一性的文件名进行MD5来建立分片文件夹，分片文件命名经过下标来命名，并写入到本地。文件上传完成后，直接删除整个文件夹便可。固然，这些文件操做都是在异步线程中完成的，防止影响UI线程。

内存占用

咱们用一个400MB的视频测试上传，咱们能够从上图看出，圈红部分是咱们上传文件的时间。将上传方式改成fromFile:后，上传文件的峰值最高也就是在10MB左右徘徊，这对于iPhone6这样的低内存老年机来讲，是至关友好的，不会致使低端设备崩溃或者卡顿。

动态分片

用户在上传时网络环境会有不少状况，WiFi、4G、弱网等不少状况。若是上传分片太大可能会致使失败率上升，分片文件过小会致使网络请求太多，产生太多无用的boundary、header、数据链路等资源的浪费。

为了解决这个问题，咱们采起的是动态分片大小的策略。根据特定的计算策略，预先使用第一个分片的上传速度当作测速分片，测速分片的大小是固定的。根据测速的结果，对其余分片大小进行动态分片，这样能够保证分片大小能够最大限度的利用当前网速。

if ([Reachability reachableViaWiFi]) {
    self.segmentSize = 500 * 1024;
} else if ([Reachability reachableViaWWAN]) {
    self.segmentSize = 300 * 1024;
}

固然，若是以为这种分片方式太过复杂，也能够采起一种阉割版的动态分片策略。即根据网络状况作判断，若是是WiFi就固定某个分片大小，若是是流量就固定某个分片大小。然而这种策略并不稳定，由于如今不少手机的网速比WiFi还快，咱们也不能保证WiFi都是百兆光纤。

并行上传

上传的全部任务若是使用的都是同一个NSURLSession的话，是能够保持链接的，省去创建和断开链接的消耗。在iOS平台上，NSURLSession支持对一个Host保持4个链接，因此，若是咱们采起并行上传，能够更好的利用当前的网络。

并行上传的数量在iOS平台上不要超过4个，最大链接数是能够经过NSURLSessionConfiguration设置的，并且数量最好不要写死。一样的，应该基于当前网络环境，在上传任务开始的时候就计算好最大链接数，并设置给Configuration。

通过咱们的线上用户数据分析，在线上环境使用并行任务的方式上传，上传速度相较于串行上传提高四倍左右。计算方式是每秒文件上传的大小。

iPhone串行上传：715 kb/s
iPhone并行上传：2909 kb/s

队列管理

分片上传过程当中可能会由于网速等缘由，致使上传失败。失败的任务应该由单独的队列进行管理，而且在合适的时机进行失败重传。

例如对一个500MB的文件进行分片，每片是300KB，就会产生1700多个分片文件，每个分片文件就对应一个上传任务。若是在进行上传时，一口气建立1700多个uploadTask，尽管NSURLSession是能够承受的，也不会形成一个很大的内存峰值。可是我以为这样并不太好，实际上并不会同时有这么多请求发出。

/// 已上传成功片断数组
@property (nonatomic, strong) NSMutableArray *successSegments;
/// 待上传队列的数组
@property (nonatomic, strong) NSMutableArray *uploadSegments;

因此在建立上传任务时，我设置了一个最大任务数，就是同时向NSURLSession发起的请求不会超过这个数量。须要注意的是，这个最大任务数是我建立uploadTask的任务数，并非最大并发数，最大并发数由NSURLSession来控制，我不作干预。

我将待上传任务都放在uploadSegments中，上传成功后我会从待上传任务数组中取出一条或多条，并保证同时进行的任务始终不超过最大任务数。失败的任务理论上来讲也是须要等待上传的，因此我把失败任务也放在uploadSegments中，插入到队列最下面，这样就保证了待上传任务完成后，继续重试失败任务。

成功的任务我放在successSegments中，而且始终保持和uploadSegments没有交集。两个队列中保存的并非uploadTask，而是分片的索引，这也就是为何我给分片命名的时候用索引当作名字的缘由。当successSegments等于分片数量时，就表示全部任务上传完成。

文件下载

NSURLSession是在单独的进程中运行，因此经过此类发起的网络请求，是独立于应用程序运行的，即便App挂起、kill也不会中止请求。在下载任务时会比较明显，即使App被kill下载任务仍然会继续，而且容许下次启动App使用此次的下载结果或继续下载。

和上传代码同样，建立下载任务很简单，经过NSURLSession建立一个downloadTask，并调用resume便可开启一个下载任务。

NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
NSURLSession *session = [NSURLSession sessionWithConfiguration:config 
                                                      delegate:self 
                                                 delegateQueue:[NSOperationQueue mainQueue]];

NSURL *url = [NSURL URLWithString:@"http://vfx.mtime.cn/Video/2017/03/31/mp4/170331093811717750.mp4"];
NSURLRequest *request = [[NSURLRequest alloc] initWithURL:url];
NSURLSessionDownloadTask *downloadTask = [session downloadTaskWithRequest:request];
[downloadTask resume];

咱们能够调用suspend将下载任务挂起，随后调用resume方法继续下载任务，suspend和resume须要是成对的。可是suspend挂起任务是有超时的，默认为60s，若是超时系统会将TCP链接断开，咱们再调用resume是失效的。能够经过NSURLSessionConfiguration的timeoutIntervalForResource来设置上传和下载的资源耗时。suspend只针对于下载任务，其余任务挂起后将会从新开始。

下面两个方法是下载比较基础的方法，分别用来接收下载进度和下载完的临时文件地址。didFinishDownloadingToURL:方法是required，当下载结束后下载文件被写入在Library/Caches下的一个临时文件，咱们须要将此文件移动到本身的目录，临时目录在将来的一个时间会被删掉。

// 从服务器接收数据，下载进度回调
- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask
             didWriteData:(int64_t)bytesWritten
        totalBytesWritten:(int64_t)totalBytesWritten
totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite {
    CGFloat progress = (CGFloat)totalBytesWritten / (CGFloat)totalBytesExpectedToWrite;
    self.progressView.progress = progress;
}

// 下载完成后回调
- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask
didFinishDownloadingToURL:(NSURL *)location {
    
}

断点续传

HTTP协议支持断点续传操做，在开始下载请求时经过请求头设置Range字段，标示从什么位置开始下载。

Range:bytes=512000-

服务端收到客户端请求后，开始从512kb的位置开始传输数据，并经过Content-Range字段告知客户端传输数据的起始位置。

Content-Range:bytes 512000-/1024000

downloadTask任务开始请求后，能够调用cancelByProducingResumeData:方法能够取消下载，而且能够得到一个resumeData，resumeData中存放一些断点下载的信息。能够将resumeData写到本地，后面经过这个文件能够进行断点续传。

NSString *library = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES).firstObject;
NSString *resumePath = [library stringByAppendingPathComponent:[self.downloadURL md5String]];
[self.downloadTask cancelByProducingResumeData:^(NSData * _Nullable resumeData) {
    [resumeData writeToFile:resumePath atomically:YES];
}];

在建立下载任务前，能够判断当前任务有没有以前待恢复的任务，若是有的话调用downloadTaskWithResumeData:方法并传入一个resumeData，能够恢复以前的下载，并从新建立一个downloadTask任务。

NSString *library = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES).firstObject;
NSString *resumePath = [library stringByAppendingPathComponent:[self.downloadURL md5String]];
NSData *resumeData = [[NSData alloc] initWithContentsOfFile:resumePath];
self.downloadTask = [self.session downloadTaskWithResumeData:resumeData];
[self.downloadTask resume];

经过suspend和resume这种方式挂起的任务，downloadTask是同一个对象，而经过cancel而后resumeData恢复的任务，会建立一个新的downloadTask任务。

当调用downloadTaskWithResumeData:方法恢复下载后，会回调下面的方法。回调参数fileOffset是上次文件的下载大小，expectedTotalBytes是预估的文件总大小。

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask
 didResumeAtOffset:(int64_t)fileOffset
expectedTotalBytes:(int64_t)expectedTotalBytes;

后台下载

经过backgroundSessionConfigurationWithIdentifier方法建立后台上传或后台下载类型的NSURLSessionConfiguration，而且设置一个惟一标识，须要保证这个标识在不一样的session之间的惟一性。后台任务只支持http和https的任务，其余协议的任务并不支持。

NSURLSessionConfiguration *config = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:@"identifier"];
[NSURLSession sessionWithConfiguration:config delegate:self delegateQueue:[NSOperationQueue mainQueue]];

经过backgroundSessionConfigurationWithIdentifier方法建立的NSURLSession，请求任务将会在系统的单独进程中进行，所以即便App进程被kill也不受影响，依然能够继续执行请求任务。若是程序被系统kill调，下次启动并执行didFinishLaunchingWithOptions能够经过相同的identifier建立NSURLSession和NSURLSessionConfiguration，系统会将新建立的NSURLSession和单独进程中正在运行的NSURLSession进行关联。

在程序启动并执行didFinishLaunchingWithOptions方法时，按照下面方法建立NSURLSession便可将新建立的Session和以前的Session绑定，并自动开始执行以前的下载任务。恢复以前的任务后会继续执行NSURLSession的代理方法，并执行后面的任务。

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    
    NSURLSessionConfiguration *config = [NSURLSessionConfiguration backgroundSessionConfigurationWithIdentifier:@"identifier"];
    [NSURLSession sessionWithConfiguration:config delegate:self delegateQueue:[NSOperationQueue mainQueue]];
    
    return YES;
}

当应用进入到后台时，能够继续下载，若是客户端没有开启Background Mode，则不会回调客户端进度。下次进入前台时，会继续回调新的进度。

若是在后台下载完成，则会经过AppDelegate的回调方法通知应用来刷新UI。因为下载是在一个单独的进程中完成的，即使业务层代码会中止执行，但下载的回调依然会被调用。在回调时，容许用户处理业务逻辑，以及刷新UI。

调用此方法后能够开始刷新UI，调用completionHandler表示刷新结束，因此上层业务要作一些控制逻辑。didFinishDownloadingToURL的调用时机会比此方法要晚，依然在那个方法里能够判断下载文件。因为项目中可能会存在多个下载任务，因此须要经过identifier对下载任务进行区分。

- (void)application:(UIApplication *)application handleEventsForBackgroundURLSession:(NSString *)identifier completionHandler:(void (^)(void))completionHandler {
    ViewController *vc = (ViewController *)self.window.rootViewController;
    vc.completionHandler = completionHandler;
}

须要注意的是，若是存在多个相同名字的identifier任务，则建立的session会将同名的任务都继续执行。NSURLSessionConfiguration还提供下面的属性，在session下载任务完成时是否启动App，默认为YES，若是设置为NO则后台下载会受到影响。

@property BOOL sessionSendsLaunchEvents;

后台下载过程当中会设计到一系列的代理方法调用，下面是调用顺序。

后台下载时序图

视频文件下载

如今不少视频类App都有视频下载的功能，视频下载确定不会是单纯的把一个mp4下载下来就能够，这里就讲一下视频下载相关的知识。

  1. 视频地址通常都是从服务端获取的，因此须要先请求接口获取下载地址。这个地址能够是某个接口就已经请求下来的，也能够是某个固定格式拼接的。
  2. 如今有不少视频App都是有免流服务的，例如腾讯大王卡、蚂蚁宝卡之类的，免流服务的本质就是对m3u8、ts、mp4地址从新包一层，请求数据的时候直接请求运营商给的地址，运营商对数据作了一个中转操做。
  3. 以流视频m3u8为例，有了免流地址，先下载m3u8文件。这个文件通常都是加密的，下载完成后客户端会对m3u8文件进行decode，获取到真正的m3u8文件。
  4. m3u8文件本质上是ts片断的集合，视频播放播的仍是ts片断。随后对m3u8文件进行解析，获取到ts片断地址，并将ts下载地址转成免流地址后逐个下载，也能够并行下载。
  5. m3u8文件下载后会以固定格式存在文件夹下，文件夹对应被缓存的视频。ts片命名以数字命名，例如0.ts，下标从0开始。
  6. 全部ts片断下载完成后，生成本地m3u8文件。
  7. m3u8文件分为远端和本地两种，远端的就是正常下载的地址，本地m3u8文件是在播放本地视频的时候传入。格式和普通m3u8文件差很少，区别在于ts地址是本地地址，例以下面的地址。
#EXTM3U
#EXT-X-TARGETDURATION:30
#EXT-X-VERSION:3
#EXTINF:9.28,
0.ts
#EXTINF:33.04,
1.ts
#EXTINF:30.159,
2.ts
#EXTINF:23.841,
3.ts
#EXT-X-ENDLIST
m3u8文件

HLS(Http Live Streaming)是苹果推出的流媒体协议，其中包含两部分，m3u8文件和ts文件。使用ts文件的缘由是由于多个ts能够无缝拼接，而且单个ts能够单独播放。而mp4因为格式缘由，被分割的mp4文件单独播放会致使画面撕裂或者音频缺失的问题。若是单独下载多个mp4文件，播放时会致使间断的问题。

m3u8是Unicode版本的m3u，是苹果推出的一种视频格式，是一个基于HTTP的流媒体传输协议。m3u8协议将一个媒体文件切为多个小文件，并利用HTTP协议进行数据传输，小文件所在的资源服务器路径存储在.m3u8文件中。客户端拿到m3u8文件，便可根据文件中资源文件的路径，分别下载不一样的文件。

m3u8文件必须是utf-8格式编码的，在文件中以#EXT开头的是标签，而且大小写敏感。以#开头的其余字符串则都会被认为是注释。m3u8分为点播和直播，点播在第一次请求.m3u8文件后，将下载下来的ts片断进行顺序播放便可。直播则须要过一段时间对.m3u8文件进行一个增量下载，并继续下载后续的ts文件。

m3u8中有不少标签，下面是项目中用到的一些标签或主要标签。将mp4或者flv文件进行切片很简单，直接用ffmpeg命令切片便可。

  • 起始标签，此标签必须在整个文件的开头。

#EXTM3U

  • 结束标签，此标签必须在整个文件的末尾。

#EXT-X-ENDLIST

  • 当前文件版本，若是不指定则默认为1

#EXT-X-VERSION

  • 全部ts片断最大时长。

#EXT-X-TARGETDURATION

  • 当前ts片断时长。

#EXTINF

若是没有#EXT或#开头的，通常都是ts片断下载地址。路径能够是绝对路径，也能够是相对路径，咱们项目里使用的是绝对路径。但相对路径数据量会相对比较小，只不过看视频的人网速不会太差。

下面是相对路径地址，文件中只有segment1.ts，则表示相对于m3u8的路径，也就是下面的路径。

https://data.vod.itc.cn/m3u8
https://data.vod.itc.cn/segment1.ts

常见错误

A background URLSession with identifier backgroundSession already exists

若是重复后台已经存在的下载任务，会提示这个错误。须要在页面退出或程序退出时，调用finishTasksAndInvalidate方法将任务invalidate。

[[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(willTerminateNotification)
                                                 name:UIApplicationWillTerminateNotification
                                               object:nil];
                                               
- (void)willTerminateNotification {
    [self.session getAllTasksWithCompletionHandler:^(NSArray<__kindof NSURLSessionTask *> * _Nonnull tasks) {
        if (tasks.count) {
            [self.session finishTasksAndInvalidate];
        }
    }];
}
联系我们 沪ICP备2021010478号-7