AFNetWorking3 源码学习—AFURLSessionM

作者: Claire_wu | 来源:发表于2017-11-13 15:19 被阅读119次

0 AFNetWorking3框架组成

将AF下载导入工程后，下面是其包结构：

image.png

除去Support Files，可以看到AF分为如下5个功能模块：

网络通信模块(NSURLSession)
网络状态监听模块(Reachability)
网络通信安全策略模块(Security)
网络通信信息序列化/反序列化模块(Serialization)
对于iOS UIKit库的扩展(UIKit)

其核心当然是网络通信模块，其余的四个模块，均是为了配合网络通信或对已有UIKit的一个扩展及工具包。
这五个模块所对应的类的结构关系图如下所示：

image.png

可以看到，AF的核心是AFURLSessionManager类，AFHTTPSessionManager继承于AFURLSessionManager，针对HTTP协议传输做了特化。而AFURLResponseSerialization， AFSecurityPolicy, AFNetworkReachabilityManager则被AFURLSessionManager所用。

1 AFURLSessionManager

AFNetworking是基于NSURLSession实现的。回想一下NSURLSession的使用方式：

创建NSURLSessionConfig对象
用之前创建的NSURLSessionConfig对象创建配置NSURLSession对象。
用NSURLSession对象创建对应的task对象并用resume方法执行之。
用delegate方法或completion block 响应网络事件及数据。

- (IBAction)test:(id)sender {
    // 快捷方式获得session对象
    NSURLSession *session = [NSURLSession sharedSession];
    NSURL *url = [NSURL URLWithString:@"http://www.daka.com/login?username=daka&pwd=123"];
    // 通过URL初始化task,在block内部可以直接对返回的数据进行处理
    NSURLSessionTask *task = [session dataTaskWithURL:url
                                    completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                        NSLog(@"%@", [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:nil]);
                                    }];
    
    // 启动任务
    [task resume];
}

对应于每次网络会话（这里可以简单理解为一个网页），对应一个NSURLSession对象，而每个会话，可以生成若干task对象用于数据的交互。
而在AFNet中， AFURLSessionManager作为核心类，封装并提供了上述网络交互功能。

1.1 AFURLSessionManager组成

AFNet运用了组合的设计模式，将不同功能搭建成AFURLSessionManager的功能。

组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
有时候又叫做部分-整体模式，它使我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

重要的是我们要先了解AFURLSessionManager的主要属性：

/**
AFURLSessionManager所管理的Session对象 
 The managed session.
 */
@property (readonly, nonatomic, strong) NSURLSession *session;

/**
delegate所返回的NSOperationQueue 
 The operation queue on which delegate callbacks are run.
 */
@property (readonly, nonatomic, strong) NSOperationQueue *operationQueue;

/**
解析网络返回数据的对象（遵循AFURLResponseSerialization协议） 
 Responses sent from the server in data tasks created with `dataTaskWithRequest:success:failure:` and run using the `GET` / `POST` / et al. convenience methods are automatically validated and serialized by the response serializer. By default, this property is set to an instance of `AFJSONResponseSerializer`.
 @warning `responseSerializer` must not be `nil`.
 */
@property (nonatomic, strong) id <AFURLResponseSerialization> responseSerializer;


///-------------------------------
/// @name Managing Security Policy
///-------------------------------


/**
用于处理网络连接安全处理策略的AFSecurityPolicy对象 
 The security policy used by created session to evaluate server trust for secure connections. `AFURLSessionManager` uses the `defaultPolicy` unless otherwise specified.
 */
@property (nonatomic, strong) AFSecurityPolicy *securityPolicy;


#if !TARGET_OS_WATCH
///--------------------------------------
/// @name Monitoring Network Reachability
///--------------------------------------


/**
用于处理网络连接安全处理策略的AFSecurityPolicy对象 
 The network reachability manager. `AFURLSessionManager` uses the `sharedManager` by default.
 */
@property (readwrite, nonatomic, strong) AFNetworkReachabilityManager *reachabilityManager;
#endif


///----------------------------
/// @name Getting Session Tasks
///----------------------------


/**
当前session创建的所有Task，这个是下面三种task的总和。
 The data, upload, and download tasks currently run by the managed session.
 */
@property (readonly, nonatomic, strong) NSArray <NSURLSessionTask *> *tasks;

/**当前session创建的DataTask
 The data tasks currently run by the managed session.
 */
@property (readonly, nonatomic, strong) NSArray <NSURLSessionDataTask *> *dataTasks;

/**当前session创建的uploadTask
 The upload tasks currently run by the managed session.
 */
@property (readonly, nonatomic, strong) NSArray <NSURLSessionUploadTask *> *uploadTasks;

/**当前session创建的downloadTask
 The download tasks currently run by the managed session.
 */
@property (readonly, nonatomic, strong) NSArray <NSURLSessionDownloadTask *> *downloadTasks;

///-------------------------------
/// @name Managing Callback Queues
///-------------------------------

/**//用于处理任务回调的GCD对象，默认是dispatch_main_queue。
 The dispatch queue for `completionBlock`. If `NULL` (default), the main queue is used.
 */
@property (nonatomic, strong, nullable) dispatch_queue_t completionQueue;

/**//用于处理任务回调的GCD的group对象，如果不初始化、则一个默认的Group被使用。
 The dispatch group for `completionBlock`. If `NULL` (default), a private dispatch group is used.
 */
@property (nonatomic, strong, nullable) dispatch_group_t completionGroup;

///---------------------------------
/// @name Working Around System Bugs
///---------------------------------

/**在iOS7的环境下，我们通过background模式的session创建的uploadTask有时会是nil，如果这个属性是yes，AFN会尝试再次创建uploadTask。
 Whether to attempt to retry creation of upload tasks for background sessions when initial call returns `nil`. `NO` by default.

 @bug As of iOS 7.0, there is a bug where upload tasks created for background tasks are sometimes `nil`. As a workaround, if this property is `YES`, AFNetworking will follow Apple's recommendation to try creating the task again.

 @see https://github.com/AFNetworking/AFNetworking/issues/1675
 */
@property (nonatomic, assign) BOOL attemptsToRecreateUploadTasksForBackgroundSessions;

1.2 运用AFURLSessionManager完成网络请求

使用AFRULSessionManager获取网络数据，仅需如下几个步骤：

// step1. 初始化AFURLSessionManager对象
NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
AFURLSessionManager *manager = [[AFURLSessionManager alloc] initWithSessionConfiguration:configuration];

// step2. 获取AFURLSessionManager的task对象
NSURLSessionDataTask *dataTask = [manager dataTaskWithRequest:request completionHandler:^(NSURLResponse *response, id responseObject, NSError *error) {
      if (error) {
           NSLog(@"Error: %@", error);
      } else {
           NSLog(@"Get Net data success!");
      }
}];

// step3. 发动task
[dataTask resume];

下面我们来一步步分析是怎么完成网络请求的

step1. 初始化AFURLSessionManager对象

要进行网络请求，第一步就是初始化AFURLSessionManager，调用函数

- (instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)configuration

该函数很简单，只有一个NSURLSessionConfiguration用来配置AFURLSessionManager所管理的NSURLSession对象。
它的实现代码如下：

(instancetype)initWithSessionConfiguration:(NSURLSessionConfiguration *)configuration {
    self = [super init];
    if (!self) {
        return nil;
    }
    // =============== 设置NSURLSession ===============
    // 若configuration为nil，则采用默认defaultSessionConfiguration

    if (!configuration) {
        configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
    }

    self.sessionConfiguration = configuration;
    // session 的delegate callback queue， 最大并发为1 
    self.operationQueue = [[NSOperationQueue alloc] init];
    self.operationQueue.maxConcurrentOperationCount = 1;
    // 初始化所管理的session
    self.session = [NSURLSession sessionWithConfiguration:self.sessionConfiguration delegate:self delegateQueue:self.operationQueue];

// =============== 设置response 数据序列化 ===============
    self.responseSerializer = [AFJSONResponseSerializer serializer];

// =============== 设置网络安全策略 ===============
    self.securityPolicy = [AFSecurityPolicy defaultPolicy];

// =============== 设置网络状态监控Manager（注意这里是一个全局单例实现） ===============
#if !TARGET_OS_WATCH
    self.reachabilityManager = [AFNetworkReachabilityManager sharedManager];
#endif
// =============== 设置存储NSURL task与AFURLSessionManagerTaskDelegate的词典（重点，在AFNet中，每一个task都会被匹配一个AFURLSessionManagerTaskDelegate 来做task的delegate事件处理） ===============
    self.mutableTaskDelegatesKeyedByTaskIdentifier = [[NSMutableDictionary alloc] init];

// =============== 设置AFURLSessionManagerTaskDelegate 词典的锁，确保词典在多线程访问时的线程安全===============
    self.lock = [[NSLock alloc] init];
    self.lock.name = AFURLSessionManagerLockName;


// =============== 为所管理的session的所有task设置完成块（这里不是很明白，既然是初始化函数，那么应该没有任何task在运行才是，怎么需要在这里设置完成块呢？？？）===============
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        for (NSURLSessionDataTask *task in dataTasks) {
            [self addDelegateForDataTask:task uploadProgress:nil downloadProgress:nil completionHandler:nil];
        }

        for (NSURLSessionUploadTask *uploadTask in uploadTasks) {
            [self addDelegateForUploadTask:uploadTask progress:nil completionHandler:nil];
        }

        for (NSURLSessionDownloadTask *downloadTask in downloadTasks) {
            [self addDelegateForDownloadTask:downloadTask progress:nil destination:nil completionHandler:nil];
        }
    }];
 // =============== 返回初始化好的self ===============
    return self;
}

这就是AFURLSessionManager的初始化函数，主要是对其属性进行初始化，要注意的是它的私有属性

@property (readwrite, nonatomic, strong) NSMutableDictionary *mutableTaskDelegatesKeyedByTaskIdentifier;
@property (readwrite, nonatomic, strong) NSLock *lock;

AFURLSessionManager会为每一个所管理的task对应创建一个AFURLSessionManagerTaskDelegate对象，Manager会交ManagerTaskDelegate对象由来具体处理各个task事物，从而实现了同一个AFURLSessionManager对多个task的管理。

step2. 获取AFURLSessionManager的task对象

当初始化好AFURLSessionManager后，就需要获取一个代表我们当前网络请求的task了：

//创建一个NSURLSessionDataTask
- (NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request
                            completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject,  NSError * _Nullable error))completionHandler;
//创建一个NSURLSessionDataTask,并且能获取上传或者下载进度
- (NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request
                               uploadProgress:(nullable void (^)(NSProgress *uploadProgress))uploadProgressBlock
                             downloadProgress:(nullable void (^)(NSProgress *downloadProgress))downloadProgressBlock
                            completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject,  NSError * _Nullable error))completionHandler;

//创建一个上传Task，并且指定上传文件的路径。
- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request
                                         fromFile:(NSURL *)fileURL
                                         progress:(nullable void (^)(NSProgress *uploadProgress))uploadProgressBlock
                                completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject, NSError  * _Nullable error))completionHandler;
////创建一个上传Task，并且指定上传的数据。
- (NSURLSessionUploadTask *)uploadTaskWithRequest:(NSURLRequest *)request
                                         fromData:(nullable NSData *)bodyData
                                         progress:(nullable void (^)(NSProgress *uploadProgress))uploadProgressBlock
                                completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject, NSError * _Nullable error))completionHandler;
//创建一个uploadTask，然后上传数据
- (NSURLSessionUploadTask *)uploadTaskWithStreamedRequest:(NSURLRequest *)request
                                                 progress:(nullable void (^)(NSProgress *uploadProgress))uploadProgressBlock
                                        completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject, NSError * _Nullable error))completionHandler;
//新建一个download任务，destination表示的下载文件的缓存路径
- (NSURLSessionDownloadTask *)downloadTaskWithRequest:(NSURLRequest *)request
                                             progress:(nullable void (^)(NSProgress *downloadProgress))downloadProgressBlock
                                          destination:(nullable NSURL * (^)(NSURL *targetPath, NSURLResponse *response))destination
                                    completionHandler:(nullable void (^)(NSURLResponse *response, NSURL * _Nullable filePath, NSError * _Nullable error))completionHandler;
//继续恢复一个download任务。resumeData参数表示的是恢复下载的时候初始化数据，比如前面已经下载好的部分数据。
- (NSURLSessionDownloadTask *)downloadTaskWithResumeData:(NSData *)resumeData
                                                progress:(nullable void (^)(NSProgress *downloadProgress))downloadProgressBlock
                                             destination:(nullable NSURL * (^)(NSURL *targetPath, NSURLResponse *response))destination
                                       completionHandler:(nullable void (^)(NSURLResponse *response, NSURL * _Nullable filePath, NSError * _Nullable error))completionHandler;
//获取指定Task的上传进度
- (nullable NSProgress *)uploadProgressForTask:(NSURLSessionTask *)task;
//获取指定Task的下载进度
- (nullable NSProgress *)downloadProgressForTask:(NSURLSessionTask *)task;

这里我们仅分析最简单的data task，仅一行代码，调用自身另一方法：

return [self dataTaskWithRequest:request uploadProgress:nil downloadProgress:nil completionHandler:completionHandler];

其实现如下：

- (NSURLSessionDataTask *)dataTaskWithRequest:(NSURLRequest *)request
                               uploadProgress:(nullable void (^)(NSProgress *uploadProgress)) uploadProgressBlock
                             downloadProgress:(nullable void (^)(NSProgress *downloadProgress)) downloadProgressBlock
                            completionHandler:(nullable void (^)(NSURLResponse *response, id _Nullable responseObject,  NSError * _Nullable error))completionHandler {

    __block NSURLSessionDataTask *dataTask = nil;
    //1. 生成一个data task对象，并返回。 
    url_session_manager_create_task_safely(^{
        dataTask = [self.session dataTaskWithRequest:request];
    });
    //2. 为该data task对象生成一个匹配的AFURLSessionManagerTaskDelegate对象，并关联之。
    [self addDelegateForDataTask:dataTask uploadProgress:uploadProgressBlock downloadProgress:downloadProgressBlock completionHandler:completionHandler];
    return dataTask;
}

上述方法完成了两件事情：
1.生成一个data task对象，并返回。
2.为该data task对象生成一个匹配的AFURLSessionManagerTaskDelegate对象，并关联之。
我们现在应该着重了解第二步关联AFURLSessionManagerTaskDelegate对象：

- (void)addDelegateForDataTask:(NSURLSessionDataTask *)dataTask
                uploadProgress:(nullable void (^)(NSProgress *uploadProgress)) uploadProgressBlock
              downloadProgress:(nullable void (^)(NSProgress *downloadProgress)) downloadProgressBlock
             completionHandler:(void (^)(NSURLResponse *response, id responseObject, NSError *error))completionHandler
{
    // 创建AFURLSessionManagerTaskDelegate对象
    AFURLSessionManagerTaskDelegate *delegate = [[AFURLSessionManagerTaskDelegate alloc] init];

    // AFURLSessionManagerTaskDelegate与AFURLSessionManager建立相互关系
    delegate.manager = self;

    // 设置AF delegate的完成块为用户传入的完成块
    delegate.completionHandler = completionHandler;

    // 设置dataTask的taskDescription
    dataTask.taskDescription = self.taskDescriptionForSessionTasks;

    // ***** 将AF delegate对象与 dataTask建立关系
    [self setDelegate:delegate forTask:dataTask];

    // 设置AF delegate的上传进度，下载进度块。
    delegate.uploadProgressBlock = uploadProgressBlock;
    delegate.downloadProgressBlock = downloadProgressBlock;
}

- (void)setDelegate:(AFURLSessionManagerTaskDelegate *)delegate
            forTask:(NSURLSessionTask *)task
{
    NSParameterAssert(task);
    NSParameterAssert(delegate);
    // 加锁，确保词典的线程安全
    [self.lock lock];

    // 将AF delegate放入以taskIdentifier标记的词典中（同一个NSURLSession中的taskIdentifier是唯一的）
    self.mutableTaskDelegatesKeyedByTaskIdentifier[@(task.taskIdentifier)] = delegate;

    // 为AF delegate 设置task 的progress监听
    [delegate setupProgressForTask:task];
    [self addNotificationObserverForTask:task];

    // 词典操作完毕，解锁
    [self.lock unlock];
}

AFNet通过封装AFURLSessionManagerTaskDelegate对象，对每个task进行管理，而AFURLSessionManager仅需要管理建立task 与AF delegate的词典即可，实现了AFURLSessionManager功能的下放。

AFURLSessionManager会将每个AF delegate放入其词典中，同时，AF delegate会监听每个task的进度，这是通过[delegate setupProgressForTask:task]实现的。我们继续看 AF delegate是如何监听task的各种进度的：

#pragma mark - NSProgress Tracking

- (void)setupProgressForTask:(NSURLSessionTask *)task {
    __weak __typeof__(task) weakTask = task;

    self.uploadProgress.totalUnitCount = task.countOfBytesExpectedToSend;
    self.downloadProgress.totalUnitCount = task.countOfBytesExpectedToReceive;
    [self.uploadProgress setCancellable:YES];
    [self.uploadProgress setCancellationHandler:^{
        __typeof__(weakTask) strongTask = weakTask;
        [strongTask cancel];
    }];
    [self.uploadProgress setPausable:YES];
    [self.uploadProgress setPausingHandler:^{
        __typeof__(weakTask) strongTask = weakTask;
        [strongTask suspend];
    }];
    if ([self.uploadProgress respondsToSelector:@selector(setResumingHandler:)]) {
        [self.uploadProgress setResumingHandler:^{
            __typeof__(weakTask) strongTask = weakTask;
            [strongTask resume];
        }];
    }

    [self.downloadProgress setCancellable:YES];
    [self.downloadProgress setCancellationHandler:^{
        __typeof__(weakTask) strongTask = weakTask;
        [strongTask cancel];
    }];
    [self.downloadProgress setPausable:YES];
    [self.downloadProgress setPausingHandler:^{
        __typeof__(weakTask) strongTask = weakTask;
        [strongTask suspend];
    }];

    if ([self.downloadProgress respondsToSelector:@selector(setResumingHandler:)]) {
        [self.downloadProgress setResumingHandler:^{
            __typeof__(weakTask) strongTask = weakTask;
            [strongTask resume];
        }];
    }

    // 这里为什么要用NSStringFromSelector 而不直接使用NSString???
    [task addObserver:self
           forKeyPath:NSStringFromSelector(@selector(countOfBytesReceived))
              options:NSKeyValueObservingOptionNew
              context:NULL];
    [task addObserver:self
           forKeyPath:NSStringFromSelector(@selector(countOfBytesExpectedToReceive))
              options:NSKeyValueObservingOptionNew
              context:NULL];

    [task addObserver:self
           forKeyPath:NSStringFromSelector(@selector(countOfBytesSent))
              options:NSKeyValueObservingOptionNew
              context:NULL];
    [task addObserver:self
           forKeyPath:NSStringFromSelector(@selector(countOfBytesExpectedToSend))
              options:NSKeyValueObservingOptionNew
              context:NULL];

    [self.downloadProgress addObserver:self
                            forKeyPath:NSStringFromSelector(@selector(fractionCompleted))
                               options:NSKeyValueObservingOptionNew
                               context:NULL];
    [self.uploadProgress addObserver:self
                          forKeyPath:NSStringFromSelector(@selector(fractionCompleted))
                             options:NSKeyValueObservingOptionNew
                             context:NULL];
}

上面的代码可以分为两个部分，

设置AF delegate的uploadProgress 和 downloadProgress。（注意为了防止对block对象截取产生的循环引用，将传入的task设置为了weak。但是这里的循环引用在哪里呢??? 其实这里鉴于block所造成的一系列循环引用的问题，AFNet采取了一种防御式编程的方法，对于没有必要在block中进行强引用的变量，一律采用弱引用。并且，当task置为nil后，block也没有理由继续strong引用task变量）
利用KVO，监听task属性及uploadProgress，downloadProgress属性的变化，进一步监听task的数据传输进程。

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context {
    if ([object isKindOfClass:[NSURLSessionTask class]]) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesReceived))]) {
            self.downloadProgress.completedUnitCount = [change[@"new"] longLongValue];
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesExpectedToReceive))]) {
            self.downloadProgress.totalUnitCount = [change[@"new"] longLongValue];
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesSent))]) {
            self.uploadProgress.completedUnitCount = [change[@"new"] longLongValue];
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(countOfBytesExpectedToSend))]) {
            self.uploadProgress.totalUnitCount = [change[@"new"] longLongValue];
        }
    }
    else if ([object isEqual:self.downloadProgress]) {
        if (self.downloadProgressBlock) {
            self.downloadProgressBlock(object);
        }
    }
    else if ([object isEqual:self.uploadProgress]) {
        if (self.uploadProgressBlock) {
            self.uploadProgressBlock(object);
        }
    }
}

当监控的Task属性改变时，同时改变由AF delegate所管理持有的Progress对象的属性。同时，当AF delegate的Progress对象属性改变时，调用对应的progress block。

step3. 发动task，NSURLSessionDelegate 的响应

因为AFURLSessionManager所管理的NSURLSession对象的delegate被设置为AFURLSessionManager自身，因此所有的NSURLSessionDelegate回调方法的目的地都是AFURLSessionManager，而AFURLSessionManager又会根据是否需要具体处理，会将属于AF delegate要响应的delegate，传递到对应的AF delegate去。
AFURLSessionManager 和 AFURLSessionManagerTaskDelegate 相应的delegate回调方法如下：

AFURLSessionManager 需要处理的NSURLSessionDelegate：

AFURLSessionManager 需要处理的NSURLSessionDelegate

而AFURLSessionManager对于NSSession的回调处理相对简单，不外乎两步：

如果有对应的user block，则将当前NSSession block传递至user block（此处可能会利用user block的返回值，来继续下一步操作）。
如果需要AF task delegate处理，则将该回调事件传给相应的AF task delegate。

AFURLSessionManagerTaskDelegate 需要处理的NSURLSessionDelegate仅三条，两条是对于completion的处理，另一条则是对于每个task，分别接受并记录其receive data：

AFURLSessionManagerTaskDelegate 需要处理的NSURLSessionDelegate

相应的delegate中会调用到很多的回调block，而这些回调Block主要是用于处理网络请求过程或者结束以后的数据处理、认证、通知、缓存等。我们可以通过设置这些Block来获取或者检测各种状态。相当于就是钩子函数。通过下面的这些Block，我们基本可以获取请求过程中的所有状态以及需要做的各种处理。

//设置Session出错或者无效的手的回调Block。这个Block主要在`NSURLSessionDelegate`代理的`URLSession:didBecomeInvalidWithError:`方法中执行。
- (void)setSessionDidBecomeInvalidBlock:(nullable void (^)(NSURLSession *session, NSError *error))block{
    
}
//当网络请需要的认证信息比如用户名密码已经发送了的时候，就可以通过这个Block来处理。这个Block是在`NSURLSessionDelegate`代理里面的`URLSession:didReceiveChallenge:completionHandler:`方法中被执行。注意这个是针对Session
- (void)setSessionDidReceiveAuthenticationChallengeBlock:(nullable NSURLSessionAuthChallengeDisposition (^)(NSURLSession *session, NSURLAuthenticationChallenge *challenge, NSURLCredential * _Nullable __autoreleasing * _Nullable credential))block{
    
}
////当网络请需要的认证信息比如用户名密码已经发送了的时候，就可以通过这个Block来处理。这个Block是在`NSURLSessionTaskDelegate`代理里面的`URLSession:task:didReceiveChallenge:completionHandler:`方法中被执行。注意这个是针对Task。
- (void)setTaskDidReceiveAuthenticationChallengeBlock:(nullable NSURLSessionAuthChallengeDisposition (^)(NSURLSession *session, NSURLSessionTask *task, NSURLAuthenticationChallenge *challenge, NSURLCredential * _Nullable __autoreleasing * _Nullable credential))block{
    
}
//当请求需要一个新的bodystream的时候，就可以通过这个Block来设置。这个Block在`NSURLSessionTaskDelegate` 代理协议的`URLSession:task:needNewBodyStream:`方法里面设置。
- (void)setTaskNeedNewBodyStreamBlock:(nullable NSInputStream * (^)(NSURLSession *session, NSURLSessionTask *task))block{
    
}
//当一个网络请求需要重定向的时候。就会调用这个Block。这个Block是在`NSURLSessionTaskDelegate`协议的`URLSession:willPerformHTTPRedirection:newRequest:completionHandler:`方法中调用的。
- (void)setTaskWillPerformHTTPRedirectionBlock:(nullable NSURLRequest * (^)(NSURLSession *session, NSURLSessionTask *task, NSURLResponse *response, NSURLRequest *request))block{
    
}
//可以通过设置这个Block来获取上传进度。这个Block主要在`NSURLSessionTaskDelegate`协议的 `URLSession:task:didSendBodyData:totalBytesSent:totalBytesExpectedToSend:`方法中调用.
- (void)setTaskDidSendBodyDataBlock:(nullable void (^)(NSURLSession *session, NSURLSessionTask *task, int64_t bytesSent, int64_t totalBytesSent, int64_t totalBytesExpectedToSend))block{
    
}
//设置一个Task完成以后执行的Block，这个Block在`NSURLSessionTaskDelegate`协议的 `URLSession:task:didCompleteWithError:`方法中执行。
- (void)setTaskDidCompleteBlock:(nullable void (^)(NSURLSession *session, NSURLSessionTask *task, NSError * _Nullable error))block{
    
}
//当接收到网络请求返回以后，可以调用这个Block。这个Block是在`NSURLSessionDataDelegate`协议的 `URLSession:dataTask:didReceiveResponse:completionHandler:`
- (void)setDataTaskDidReceiveResponseBlock:(nullable NSURLSessionResponseDisposition (^)(NSURLSession *session, NSURLSessionDataTask *dataTask, NSURLResponse *response))block{
    
}
//如果一个dataTask转换为downLoadTask以后，就可以设置这个Block来调用。在`NSURLSessionDataDelegate` 协议的`URLSession:dataTask:didBecomeDownloadTask:`方法中调用。
- (void)setDataTaskDidBecomeDownloadTaskBlock:(nullable void (^)(NSURLSession *session, NSURLSessionDataTask *dataTask, NSURLSessionDownloadTask *downloadTask))block{
    
}
//当dataTask接收到数据以后，可以设置调用这个Block。具体在`NSURLSessionDataDelegate`协议的`URLSession:dataTask:didReceiveData:`方法。
- (void)setDataTaskDidReceiveDataBlock:(nullable void (^)(NSURLSession *session, NSURLSessionDataTask *dataTask, NSData *data))block{
    
}
//设置一个Block来决定是否处理或者换成网络请求缓存。具体在`NSURLSessionDataDelegate`协议的`URLSession:dataTask:willCacheResponse:completionHandler:`方法中。
- (void)setDataTaskWillCacheResponseBlock:(nullable NSCachedURLResponse * (^)(NSURLSession *session, NSURLSessionDataTask *dataTask, NSCachedURLResponse *proposedResponse))block{
    
}
//当session所有的任务都发送出去以后，就可以通过这个Block来获取。具体在`NSURLSessionDataDelegate`协议的 `URLSessionDidFinishEventsForBackgroundURLSession:`方法中。
- (void)setDidFinishEventsForBackgroundURLSessionBlock:(nullable void (^)(NSURLSession *session))block{
    
}
//当一个downloadTask执行完毕以后，可以通过这个Block来获取下载信息，我们可以通过这个Block获取下载文件的位置。具体在`NSURLSessionDownloadDelegate`协议的`URLSession:downloadTask:didFinishDownloadingToURL:`方法中被调用。
- (void)setDownloadTaskDidFinishDownloadingBlock:(nullable NSURL * _Nullable  (^)(NSURLSession *session, NSURLSessionDownloadTask *downloadTask, NSURL *location))block{
    
}
//可以通过这个Block获取一个downloadTask的下载进度。这个Block会在下载过程中多次被调用。具体是在`NSURLSessionDownloadDelegate`协议中的`URLSession:downloadTask:didWriteData:totalBytesWritten:totalBytesWritten:totalBytesExpectedToWrite:`方法中被调用。
- (void)setDownloadTaskDidWriteDataBlock:(nullable void (^)(NSURLSession *session, NSURLSessionDownloadTask *downloadTask, int64_t bytesWritten, int64_t totalBytesWritten, int64_t totalBytesExpectedToWrite))block{
    
}
//当一个downloadTask重新开始以后，我们可以通过这个Block获取fileOffSet等信息获取已经下载的部分以及总共有多少要下载。具体是在`NSURLSessionDownloadDelegate`协议的`URLSession:downloadTask:didResumeAtOffset:expectedTotalBytes:`方法中被调用。
- (void)setDownloadTaskDidResumeBlock:(nullable void (^)(NSURLSession *session, NSURLSessionDownloadTask *downloadTask, int64_t fileOffset, int64_t expectedTotalBytes))block{
    
}

1.3 AFURLSessionManager 与 AFURLSessionManagerTaskDelegate 的分工

到这里我们可以想一想，既然NSURLSession的delegate是AFURLSessionManager对象，那么为什么不在AFURLSessionManager中处理所有的事件回调，搞出来一个AFURLSessionManagerTaskDelegate干什么？

我们知道，NSURLSession的回调有很多，而当我们启动一个task，真正想要获取的信息是什么呢？就是网络请求最终所返回的数据(我所进行的网络操作成功或是失败，服务器为我返回的数据)呗！其它的回调，什么认证质询，task需要新的body stream，什么request即将重定向, 统统都是浮云，都是为了我们能够最终获取到服务器返回的数据所服务的。另外我们也想要知道我们的网络请求的进度。

总结为两点：

获取最终返回数据
获知当前请求的进度

于是，AFNetWorking 便在纷繁复杂的回调处理中，特意抽象出AFURLSessionManagerTaskDelegate，用于应付网络返回数据的处理（包括保存中间值，序列化返回值，错误处理）和网络请求进度。
这样做可以使代码结构更分明，逻辑更清晰。
这在AFURLSessionManagerTaskDelegate的声明中也可以看出一二，其属性按功能分类就两种，一种用来保存服务器返回数据及completion回调，另一种就是反应当前网络处理进度：

@interface AFURLSessionManagerTaskDelegate : NSObject <NSURLSessionTaskDelegate, NSURLSessionDataDelegate, NSURLSessionDownloadDelegate>
@property (nonatomic, weak) AFURLSessionManager *manager;
@property (nonatomic, strong) NSMutableData *mutableData; // 保存服务器返回的数据
@property (nonatomic, strong) NSProgress *uploadProgress; // 上传进度
@property (nonatomic, strong) NSProgress *downloadProgress; // 下载进度
@property (nonatomic, copy) NSURL *downloadFileURL; // 下载文件目的存储地址
@property (nonatomic, copy) AFURLSessionDownloadTaskDidFinishDownloadingBlock downloadTaskDidFinishDownloading; 
@property (nonatomic, copy) AFURLSessionTaskProgressBlock uploadProgressBlock;
@property (nonatomic, copy) AFURLSessionTaskProgressBlock downloadProgressBlock;
@property (nonatomic, copy) AFURLSessionTaskCompletionHandler completionHandler;
@end

2 参考资料

由于楼主在网络库方面还是生手，此文大部分摘自AFNetWorking(3.0)源码分析系列，目前读完一遍还有一些没有吃透，每次读都有不同的收获，希望书读百遍，其义自见吧。
AFNetWorking(3.0)源码分析系列

AFNetWorking3 源码学习—AFURLSessionM

0 AFNetWorking3框架组成

1 AFURLSessionManager

1.1 AFURLSessionManager组成

1.2 运用AFURLSessionManager完成网络请求

step1. 初始化AFURLSessionManager对象

step2. 获取AFURLSessionManager的task对象

step3. 发动task，NSURLSessionDelegate 的响应

1.3 AFURLSessionManager 与 AFURLSessionManagerTaskDelegate 的分工

2 参考资料

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

将来跳槽用

恩美第二个APP项目