iOS网络——NSURLSession详解及SDWebImage源码解析你要知道的NSURLSession都在这里

- (void)viewWillAppear:(BOOL)animated
{
    NSURLSession *session = [NSURLSession sharedSession];
    NSURL *url = [NSURL URLWithString:@"127.0.0.1:8080/login?username=cjm&password=cjmcjmcjm"];
    NSURLSessionDataTask *task = [session dataTaskWithURL:url completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        NSLog(@"%@ %@ %@ %@", data, response, error, [NSThread currentThread]);
    }];
    [task resume];
}

- (void)viewWillAppear:(BOOL)animated
{
    //创建NSURL的请求路径URL
    NSURL *url = [NSURL URLWithString:@"http://127.0.0.1:8080/login"];
    //创建一个可变的request对象
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
    //修改请求方式为POST方法，默认是GET方法
    [request setHTTPMethod:@"POST"];
    //设置请求体，即添加post请求数据
    [request setHTTPBody:[@"username=cjm&password=cjmcjmcjm" dataUsingEncoding:NSUTF8StringEncoding]];
    //使用单例的全局共享的session对象
    NSURLSession *session = [NSURLSession sharedSession];
    //使用上述request构造一个任务对象
    NSURLSessionDataTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
        NSLog(@"%@ %@ %@ %@", data, response, error, [NSThread currentThread]);
    }];
    //启动任务
    [task resume];
}

- (void)viewWillAppear:(BOOL)animated
{
    //创建文件地址URL
    NSURL *url = [NSURL URLWithString:@"http://mirrors.hust.edu.cn/apache/tomcat/tomcat-9/v9.0.1/bin/apache-tomcat-9.0.1.tar.gz"];
    //获取单例全局共享的session对象
    NSURLSession *session = [NSURLSession sharedSession];
    //创建一个下载任务
    NSURLSessionDownloadTask *downloadTask = [session downloadTaskWithURL:url completionHandler:^(NSURL * _Nullable location, NSURLResponse * _Nullable response, NSError * _Nullable error) {
       //这个location就是下载到磁盘的位置，默认是在沙盒tmp文件夹中国
        NSLog(@"Location %@", location);
        //tmp文件夹在关闭app后会自动删除，有需要可以使用NSFileManager将该文件转移到沙盒其他目录下      
        //NSFileManager *fileManager = [NSFileManager defaultManager];
        //[fileManager copyItemAtPath:location.path toPath:@"" error:nil];  
    }];
    //启动任务
    [downloadTask resume];
}

- (void)viewWillAppear:(BOOL)animated
{
    //创建一个代理方法执行的队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    //设置队列的名称
    queue.name = @"MyDelegateQueue";
    //创建一个session，运行在默认模式下
    //设置代理和代理方法执行队列
    NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:self delegateQueue:queue];
    //创建一个任务
    NSURLSessionDataTask *task = [session dataTaskWithURL:[NSURL URLWithString:@"http://www.baidu.com"]];
    //启动任务
    [task resume];
    
}

//一次请求只会执行一次，收到服务端响应
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask
didReceiveResponse:(NSURLResponse *)response
 completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler
{
    NSLog(@"Receive Response %@ %@ %@", response, [NSThread currentThread], [NSOperationQueue currentQueue]);
    /*
    如果要实现这个代理方法一定要执行这个回调块
    如果不执行这个回调块默认就会取消任务，后面就不会从服务器获取数据了
    */
    if (completionHandler) {
        completionHandler(NSURLSessionResponseAllow);
    }
}

//从服务端收到数据，一次请求中可能执行多次
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask
    didReceiveData:(NSData *)data
{
    NSLog(@"Receive Data %@",  [NSOperationQueue currentQueue]);
}

//任务完成后的回调
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task
didCompleteWithError:(nullable NSError *)error
{
    NSLog(@"Complete %@ %@", error, [NSOperationQueue currentQueue]);
}

Receive Response <NSHTTPURLResponse: 0x1c4223260> { URL: http://www.baidu.com/ } { status code: 200, headers {
    BDPAGETYPE = 1;
    BDQID = 0x93412d1800009b30;
    BDUSERID = 0;
    "Cache-Control" = private;
    Connection = "Keep-Alive";
    "Content-Encoding" = gzip;
    "Content-Type" = "text/html; charset=utf-8";
    "Cxy_all" = "baidu+f27780376a7d65c99c3592e1ecb801b0";
    Date = "Wed, 01 Nov 2017 08:12:34 GMT";
    Expires = "Wed, 01 Nov 2017 08:12:00 GMT";
    Server = "BWS/1.1";
    "Set-Cookie" = "BDSVRTM=0; path=/, BD_HOME=0; path=/, H_PS_PSSID=1435_21081_17001_24879_22160; path=/; domain=.baidu.com";
    "Transfer-Encoding" = Identity;
    Vary = "Accept-Encoding";
    "X-Powered-By" = HPHP;
    "X-UA-Compatible" = "IE=Edge,chrome=1";
} } <NSThread: 0x1c0461980>{number = 4, name = (null)} <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'}
Receive Data <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'}
Receive Data <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'}
Receive Data <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'}
Receive Data <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'}
Complete (null) <NSOperationQueue: 0x1c0223c60>{name = 'MyDelegateQueue'

//声明一系列通知的名称
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadStartNotification;
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadReceiveResponseNotification;
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadStopNotification;
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadFinishNotification;

/*
SDWebImageDownloaderOperationInterface协议
开发者可以实现自己的下载操作只需要实现该协议即可
*/
@protocol SDWebImageDownloaderOperationInterface<NSObject>

//初始化函数，根据指定的request、session和下载选项创建一个下载任务
- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
                              inSession:(nullable NSURLSession *)session
                                options:(SDWebImageDownloaderOptions)options;

//添加进度和完成后的回调块
- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

//是否压缩图片的setter和getter
- (BOOL)shouldDecompressImages;
- (void)setShouldDecompressImages:(BOOL)value;

//NSURLCredential的setter和getetr
- (nullable NSURLCredential *)credential;
- (void)setCredential:(nullable NSURLCredential *)value;

@end

/*
SDWebImageDownloaderOperation类继承自NSOperation
并遵守了四个协议
SDWebImageOperation协议只有一个cancel方法
*/
@interface SDWebImageDownloaderOperation : NSOperation <SDWebImageDownloaderOperationInterface, SDWebImageOperation, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>

//下载任务的request
@property (strong, nonatomic, readonly, nullable) NSURLRequest *request;

//执行下载操作的下载任务
@property (strong, nonatomic, readonly, nullable) NSURLSessionTask *dataTask;

/*
是否压缩图片
上面的协议需要实现这个属性的getter和setter方法
只需要声明一个属性就可以遵守上面两个方法了
*/
@property (assign, nonatomic) BOOL shouldDecompressImages;

//废弃了的属性
@property (nonatomic, assign) BOOL shouldUseCredentialStorage __deprecated_msg("Property deprecated. Does nothing. Kept only for backwards compatibility");

//https需要使用的凭证
@property (nonatomic, strong, nullable) NSURLCredential *credential;

//下载时配置的相关内容
@property (assign, nonatomic, readonly) SDWebImageDownloaderOptions options;

//需要下载的文件的大小
@property (assign, nonatomic) NSInteger expectedSize;

//连接服务端后的收到的响应
@property (strong, nonatomic, nullable) NSURLResponse *response;

//初始化方法需要下载文件的request、session以及下载相关配置选项
- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
                              inSession:(nullable NSURLSession *)session
                                options:(SDWebImageDownloaderOptions)options NS_DESIGNATED_INITIALIZER;

/*
添加一个进度回调块和下载完成后的回调块
返回一个token，用于取消这个下载任务，这个token其实是一个字典，后文会讲
*/
- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

/*
这个方法不是用来取消下载任务的，而是删除前一个方法添加的进度回调块和下载完成回调块
当所有的回调块都删除后，下载任务也会被取消，具体实现在.m文件中有讲解
需要传入上一个方法返回的token，即回调块字典
*/
- (BOOL)cancel:(nullable id)token;

@end

//相关通知的名称
NSString *const SDWebImageDownloadStartNotification = @"SDWebImageDownloadStartNotification";
NSString *const SDWebImageDownloadReceiveResponseNotification = @"SDWebImageDownloadReceiveResponseNotification";
NSString *const SDWebImageDownloadStopNotification = @"SDWebImageDownloadStopNotification";
NSString *const SDWebImageDownloadFinishNotification = @"SDWebImageDownloadFinishNotification";

//进度回调块和下载完成回调块的字符串类型的key
static NSString *const kProgressCallbackKey = @"progress";
static NSString *const kCompletedCallbackKey = @"completed";

//定义了一个可变字典类型的回调块集合，这个字典key的取值就是上面两个字符串
typedef NSMutableDictionary<NSString *, id> SDCallbacksDictionary;

@interface SDWebImageDownloaderOperation ()

/*
回调块数组，数组内的元素即为前面自定义的数据类型
通过名称不难猜测，上述自定义字典的value就是回调块了
*/
@property (strong, nonatomic, nonnull) NSMutableArray<SDCallbacksDictionary *> *callbackBlocks;

/*
继承NSOperation需要定义executing和finished属性
并实现getter和setter，手动触发KVO通知
*/
@property (assign, nonatomic, getter = isExecuting) BOOL executing;
@property (assign, nonatomic, getter = isFinished) BOOL finished;

//可变NSData数据，存储下载的图片数据
@property (strong, nonatomic, nullable) NSMutableData *imageData;

//缓存的图片数据
@property (copy, nonatomic, nullable) NSData *cachedData;

/*
这里是weak修饰的NSURLSession属性
作者解释到unownedSession有可能不可用，因为这个session是外面传进来的，由其他类负责管理这个session，本类不负责管理
这个session有可能会被回收，当不可用时使用下面那个session
*/
@property (weak, nonatomic, nullable) NSURLSession *unownedSession;

/*
strong修饰的session，当上面weak的session不可用时，需要创建一个session
这个session需要由本类负责管理，需要在合适的地方调用*invalid*方法打破引用循环
*/
@property (strong, nonatomic, nullable) NSURLSession *ownedSession;

//NSURLSessionTask具体的下载任务
@property (strong, nonatomic, readwrite, nullable) NSURLSessionTask *dataTask;

//一个队列
@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t barrierQueue;

//iOS上支持在后台下载时需要一个identifier
#if SD_UIKIT
@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundTaskId;
#endif

//这个解码器在图片没有完全下载完成时也可以解码展示部分图片
@property (strong, nonatomic, nullable) id<SDWebImageProgressiveCoder> progressiveCoder;

@end

@implementation SDWebImageDownloaderOperation

@synthesize executing = _executing;
@synthesize finished = _finished;

//初始化函数，直接返回下面的初始化构造函数
- (nonnull instancetype)init {
    return [self initWithRequest:nil inSession:nil options:0];
}

- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
                              inSession:(nullable NSURLSession *)session
                                options:(SDWebImageDownloaderOptions)options {
    if ((self = [super init])) {
        _request = [request copy];
        _shouldDecompressImages = YES;
        _options = options;
        _callbackBlocks = [NSMutableArray new];
        _executing = NO;
        _finished = NO;
        _expectedSize = 0;
        _unownedSession = session;
        _barrierQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloaderOperationBarrierQueue", DISPATCH_QUEUE_CONCURRENT);
    }
    return self;
}

//析构函数
- (void)dealloc {
    SDDispatchQueueRelease(_barrierQueue);
}

//添加进度回调块和下载完成回调块
- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
    //创建一个<NSString,id>类型的可变字典，value为回调块
    SDCallbacksDictionary *callbacks = [NSMutableDictionary new];
    //如果进度回调块存在就加进字典里，key为@"progress"
    if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
    //如果下载完成回调块存在就加进字典里，key为@"completed"
    if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
    //使用dispatch_barrier_async方法异步方式不阻塞当前线程，但阻塞并发对列，串行执行添加进数组的操作
    dispatch_barrier_async(self.barrierQueue, ^{
        [self.callbackBlocks addObject:callbacks];
    });
    //返回的token其实就是这个字典
    return callbacks;
}

//通过key获取回调块数组中所有对应key的回调块
- (nullable NSArray<id> *)callbacksForKey:(NSString *)key {
    __block NSMutableArray<id> *callbacks = nil;
    //同步方式执行，阻塞当前线程也阻塞队列
    dispatch_sync(self.barrierQueue, ^{
        callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];
        //通过valueForKey方法如果字典中没有对应key会返回null所以需要删除为null的元素
        [callbacks removeObjectIdenticalTo:[NSNull null]];
    });
    return [callbacks copy];    // strip mutability here
}

//前文讲过的取消方法
- (BOOL)cancel:(nullable id)token {
    __block BOOL shouldCancel = NO;
    //同步方法阻塞队列阻塞当前线程也阻塞队列
    dispatch_barrier_sync(self.barrierQueue, ^{
        //根据token删除数组中的数据，token就是key为string，value为block的字典
        //删除的就是数组中的字典元素
        [self.callbackBlocks removeObjectIdenticalTo:token];
        //如果回调块数组长度为0就真的要取消下载任务了，因为已经没有人来接收下载完成和下载进度的信息，下载完成也没有任何意义
        if (self.callbackBlocks.count == 0) {
            shouldCancel = YES;
        }
    });
    //如果要真的要取消任务就调用cancel方法
    if (shouldCancel) {
        [self cancel];
    }
    return shouldCancel;
}

//重写NSOperation类的start方法，任务添加到NSOperationQueue后会执行该方法，启动下载任务
- (void)start {
    /*
    同步代码块，防止产生竞争条件？
    其实这里我并不懂为什么要加这个同步代码块
    NSOperation子类加进NSOperationQueue后会自行调用start方法，并且只会执行一次，不太理解为什么需要加这个，懂的读者希望不吝赐教
    */
    @synchronized (self) {
        
        //判断是否取消了下载任务
        if (self.isCancelled) {
            //如果取消了就设置finished为YES，调用reset方法
            self.finished = YES;
            [self reset];
            return;
        }

        //iOS里支持可以在app进入后台后继续下载
#if SD_UIKIT
        Class UIApplicationClass = NSClassFromString(@"UIApplication");
        BOOL hasApplication = UIApplicationClass && [UIApplicationClass respondsToSelector:@selector(sharedApplication)];
        if (hasApplication && [self shouldContinueWhenAppEntersBackground]) {
            __weak __typeof__ (self) wself = self;
            UIApplication * app = [UIApplicationClass performSelector:@selector(sharedApplication)];
            self.backgroundTaskId = [app beginBackgroundTaskWithExpirationHandler:^{
                __strong __typeof (wself) sself = wself;

                if (sself) {
                    [sself cancel];

                    [app endBackgroundTask:sself.backgroundTaskId];
                    sself.backgroundTaskId = UIBackgroundTaskInvalid;
                }
            }];
        }
#endif
        //根据配置的下载选项获取网络请求的缓存数据
        if (self.options & SDWebImageDownloaderIgnoreCachedResponse) {
            // Grab the cached data for later check
            NSCachedURLResponse *cachedResponse = [[NSURLCache sharedURLCache] cachedResponseForRequest:self.request];
            if (cachedResponse) {
                self.cachedData = cachedResponse.data;
            }
        }
        
        NSURLSession *session = self.unownedSession;
        //判断unownedSession是否为nil
        if (!self.unownedSession) {
            //为空则自行创建一个NSURLSession对象
            //相关知识前文也讲解过了，session运行在默认模式下
            NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
            //超时时间15s
            sessionConfig.timeoutIntervalForRequest = 15;
            //delegateQueue为nil，所以回调方法默认在一个子线程的串行队列中执行
            self.ownedSession = [NSURLSession sessionWithConfiguration:sessionConfig
                                                              delegate:self
                                                         delegateQueue:nil];
            //局部变量赋值
            session = self.ownedSession;
        }
        //使用可用的session来创建一个NSURLSessionDataTask类型的下载任务
        self.dataTask = [session dataTaskWithRequest:self.request];
        //设置NSOperation子类的executing属性，标识开始下载任务
        self.executing = YES;
    }
    //NSURLSessionDataTask任务开始执行
    [self.dataTask resume];
    
    //如果这个NSURLSessionDataTask不为空即开启成功
    if (self.dataTask) {
        //遍历所有的进度回调块并执行
        for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
            progressBlock(0, NSURLResponseUnknownLength, self.request.URL);
        }
        /*
        在主线程中发送通知，并将self传出去
        在什么线程发送通知，就会在什么线程接收通知
        为了防止其他监听通知的对象在回调方法中修改UI，这里就需要在主线程中发送通知
        */
        __weak typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:weakSelf];
        });
    } else {
        //如果创建NSURLSessionDataTask失败就执行失败的回调块
        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Connection can't be initialized"}]];
    }

//iOS后台下载相关
#if SD_UIKIT
    Class UIApplicationClass = NSClassFromString(@"UIApplication");
    if(!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) {
        return;
    }
    if (self.backgroundTaskId != UIBackgroundTaskInvalid) {
        UIApplication * app = [UIApplication performSelector:@selector(sharedApplication)];
        [app endBackgroundTask:self.backgroundTaskId];
        self.backgroundTaskId = UIBackgroundTaskInvalid;
    }
#endif
}

//SDWebImageOperation协议的cancel方法，取消任务，调用cancelInternal方法
- (void)cancel {
    @synchronized (self) {
        [self cancelInternal];
    }
}

//真的取消下载任务的方法
- (void)cancelInternal {
    //如果下载任务已经结束了直接返回
    if (self.isFinished) return;
    //调用NSOperation类的cancel方法，即，将isCancelled属性置为YES
    [super cancel];
    
    //如果NSURLSessionDataTask下载图片的任务存在
    if (self.dataTask) {
        //调用其cancel方法取消下载任务
        [self.dataTask cancel];
        //在主线程中发出下载停止的通知
        __weak typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:weakSelf];
        });

        //设置两个属性的值
        if (self.isExecuting) self.executing = NO;
        if (!self.isFinished) self.finished = YES;
    }
    //调用reset方法
    [self reset];
}

//下载完成后调用的方法
- (void)done {
    //设置finished为YES executing为NO
    self.finished = YES;
    self.executing = NO;
    //调用reset方法
    [self reset];
}

- (void)reset {
    //删除回调块字典数组的所有元素
    __weak typeof(self) weakSelf = self;
    dispatch_barrier_async(self.barrierQueue, ^{
        [weakSelf.callbackBlocks removeAllObjects];
    });
    //NSURLSessionDataTask对象置为nil，等待回收
    self.dataTask = nil;
    
    //获取代理方法执行的队列
    NSOperationQueue *delegateQueue;
    //如果unownedSession可用就从它里面获取
    if (self.unownedSession) {
        delegateQueue = self.unownedSession.delegateQueue;
    } else {
        //不可用就从ownedSession中拿
        delegateQueue = self.ownedSession.delegateQueue;
    }
    //如果有代理方法执行队列
    if (delegateQueue) {
        //assert一下，这个队列必须为串行队列
        NSAssert(delegateQueue.maxConcurrentOperationCount == 1, @"NSURLSession delegate queue should be a serial queue");
        //将image数据置为nil
        [delegateQueue addOperationWithBlock:^{
            weakSelf.imageData = nil;
        }];
    }
    //如果ownedSession存在，就需要我们手动调用invalidateAndCancel方法打破引用循环
    if (self.ownedSession) {
        [self.ownedSession invalidateAndCancel];
        self.ownedSession = nil;
    }
}

//NSOperation子类finished属性的stter
- (void)setFinished:(BOOL)finished {
    //手动触发KVO通知
    [self willChangeValueForKey:@"isFinished"];
    _finished = finished;
    [self didChangeValueForKey:@"isFinished"];
}

//NSOperation子类finished属性的stter
- (void)setExecuting:(BOOL)executing {
    //手动触发KVO通知
    [self willChangeValueForKey:@"isExecuting"];
    _executing = executing;
    [self didChangeValueForKey:@"isExecuting"];
}

//重写NSOperation方法，标识这是一个并发任务
- (BOOL)isConcurrent {
    return YES;
}

#pragma mark NSURLSessionDataDelegate
//NSURLSessionDataDelegate代理方法

//收到服务端响应，在一次请求中只会执行一次
- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
didReceiveResponse:(NSURLResponse *)response
 completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
    //根据http状态码判断是否成功响应，需要注意的是304认为是异常响应
    //如果响应正常
    if (![response respondsToSelector:@selector(statusCode)] || (((NSHTTPURLResponse *)response).statusCode < 400 && ((NSHTTPURLResponse *)response).statusCode != 304)) {
        //获取要下载图片的长度
        NSInteger expected = (NSInteger)response.expectedContentLength;
        expected = expected > 0 ? expected : 0;
        //设置长度
        self.expectedSize = expected;
        //遍历进度回调块并触发进度回调块
        for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
            progressBlock(0, expected, self.request.URL);
        }
        //创建imageData可变数据类型，大小就为响应返回的文件大小
        self.imageData = [[NSMutableData alloc] initWithCapacity:expected];
        //将response赋值到成员变量
        self.response = response;
        //主线程中发送相关通知
        __weak typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadReceiveResponseNotification object:weakSelf];
        });
    } else {
        //如果响应不正常
        NSUInteger code = ((NSHTTPURLResponse *)response).statusCode;
        
        //如果是304则直接取消下载任务
        if (code == 304) {
            [self cancelInternal];
        } else {
            //其他则取消NSURLSessionDataTask任务，并触发URLSession:task:didCompleteWithError:代理方法
            [self.dataTask cancel];
        }
        //主线程发送相关通知
        __weak typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:weakSelf];
        });
        //触发异常回调块
        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:((NSHTTPURLResponse *)response).statusCode userInfo:nil]];
        //执行done方法
        [self done];
    }
    //如果有回调块就执行
    if (completionHandler) {
        completionHandler(NSURLSessionResponseAllow);
    }
}

//收到数据的回调方法，可能执行多次
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {
    //向可变数据中添加接收到的数据
    [self.imageData appendData:data];
    
    //如果下载选项需要支持progressive下载，即展示已经下载的部分，并且响应中返回的图片大小大于0
    if ((self.options & SDWebImageDownloaderProgressiveDownload) && self.expectedSize > 0) {
        //复制data数据
        NSData *imageData = [self.imageData copy];
        //获取已经下载了多大的数据
        const NSInteger totalSize = imageData.length;
        //判断是否已经下载完成
        BOOL finished = (totalSize >= self.expectedSize);
        //如果这个解码器不存在就创建一个
        if (!self.progressiveCoder) {
            // We need to create a new instance for progressive decoding to avoid conflicts
            for (id<SDWebImageCoder>coder in [SDWebImageCodersManager sharedInstance].coders) {
                if ([coder conformsToProtocol:@protocol(SDWebImageProgressiveCoder)] &&
                    [((id<SDWebImageProgressiveCoder>)coder) canIncrementallyDecodeFromData:imageData]) {
                    self.progressiveCoder = [[[coder class] alloc] init];
                }
            }
        }
        //将数据交给解码器返回一个图片
        UIImage *image = [self.progressiveCoder incrementallyDecodedImageWithData:imageData finished:finished];
        //如果图片存在
        if (image) {
            //通过URL获取缓存的key
            NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:self.request.URL];
            //缩放图片，不同平台图片大小计算方法不同，所以需要处理与喜爱
            image = [self scaledImageForKey:key image:image];
            //是否需要压缩
            if (self.shouldDecompressImages) {
                //压缩
                image = [[SDWebImageCodersManager sharedInstance] decompressedImageWithImage:image data:&data options:@{SDWebImageCoderScaleDownLargeImagesKey: @(NO)}];
            }
            //触发回调块回传这个图片
            [self callCompletionBlocksWithImage:image imageData:nil error:nil finished:NO];
        }
    }
    //调用进度回调块并触发进度回调块
    for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
        progressBlock(self.imageData.length, self.expectedSize, self.request.URL);
    }
}

//如果要缓存响应时回调该方法
- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
 willCacheResponse:(NSCachedURLResponse *)proposedResponse
 completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler {
    
    NSCachedURLResponse *cachedResponse = proposedResponse;
    //如果request的缓存策略是不缓存本地数据就设置为nil
    if (self.request.cachePolicy == NSURLRequestReloadIgnoringLocalCacheData) {
        // Prevents caching of responses
        cachedResponse = nil;
    }
    //调用回调块
    if (completionHandler) {
        completionHandler(cachedResponse);
    }
}

#pragma mark NSURLSessionTaskDelegate
//下载完成或下载失败时的回调方法
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
    /*
    又是一个同步代码块...有点不解，望理解的读者周知
    SDWebImage下载的逻辑也挺简单的，本类SDWebImageDownloaderOperation是NSOperation的子类
    所以可以使用NSOperationQueue来实现多线程下载
    但是每一个Operation类对应一个NSURLSessionTask的下载任务
    也就是说，SDWebImageDownloader类在需要下载图片的时候就创建一个Operation，
    然后将这个Operation加入到OperationQueue中，就会执行start方法
    start方法会创建一个Task来实现下载
    所以整个下载任务有两个子线程，一个是Operation执行start方法的线程来开启Task的下载任务
    一个是Task的线程来执行下载任务
    Operation和Task是一对一的关系，应该不会有竞争条件产生呀？
    */
    @synchronized(self) {
        //置空
        self.dataTask = nil;
        //主线程根据error是否为空发送对应通知
        __weak typeof(self) weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:weakSelf];
            if (!error) {
                [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadFinishNotification object:weakSelf];
            }
        });
    }
    
    //如果error存在，即下载过程中有我entity
    if (error) {
        //触发对应回调块
        [self callCompletionBlocksWithError:error];
    } else {
        //下载成功
        //判断下载完成回调块个数是否大于0
        if ([self callbacksForKey:kCompletedCallbackKey].count > 0) {
            //获取不可变data图片数据
            NSData *imageData = [self.imageData copy];
            //如果下载的图片存在
            if (imageData) {
                //如果下载设置只使用缓存数据就会判断缓存数据与当前获取的数据是否一致，一致就触发完成回调块
                if (self.options & SDWebImageDownloaderIgnoreCachedResponse && [self.cachedData isEqualToData:imageData]) {
                    [self callCompletionBlocksWithImage:nil imageData:nil error:nil finished:YES];
                } else {
                    //解码图片
                    UIImage *image = [[SDWebImageCodersManager sharedInstance] decodedImageWithData:imageData];
                    //获取缓存图片的唯一key
                    NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:self.request.URL];
                    //缩放图片，不同平台图片大小计算方法不同，需要设置一下
                    image = [self scaledImageForKey:key image:image];
                    //下面是GIF WebP格式数据的解码工作
                    BOOL shouldDecode = YES;
                    // Do not force decoding animated GIFs and WebPs
                    if (image.images) {
                        shouldDecode = NO;
                    } else {
#ifdef SD_WEBP
                        SDImageFormat imageFormat = [NSData sd_imageFormatForImageData:imageData];
                        if (imageFormat == SDImageFormatWebP) {
                            shouldDecode = NO;
                        }
#endif
                    }
                    
                    if (shouldDecode) {
                        if (self.shouldDecompressImages) {
                            BOOL shouldScaleDown = self.options & SDWebImageDownloaderScaleDownLargeImages;
                            image = [[SDWebImageCodersManager sharedInstance] decompressedImageWithImage:image data:&imageData options:@{SDWebImageCoderScaleDownLargeImagesKey: @(shouldScaleDown)}];
                        }
                    }
                    if (CGSizeEqualToSize(image.size, CGSizeZero)) {
                        [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Downloaded image has 0 pixels"}]];
                    } else {
                        [self callCompletionBlocksWithImage:image imageData:imageData error:nil finished:YES];
                    }
                }
            } else {
                [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Image data is nil"}]];
            }
        }
    }
    [self done];
}

//如果是https访问就需要设置SSL证书相关
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler {
    
    NSURLSessionAuthChallengeDisposition disposition = NSURLSessionAuthChallengePerformDefaultHandling;
    __block NSURLCredential *credential = nil;
    
    if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust]) {
        if (!(self.options & SDWebImageDownloaderAllowInvalidSSLCertificates)) {
            disposition = NSURLSessionAuthChallengePerformDefaultHandling;
        } else {
            credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
            disposition = NSURLSessionAuthChallengeUseCredential;
        }
    } else {
        if (challenge.previousFailureCount == 0) {
            if (self.credential) {
                credential = self.credential;
                disposition = NSURLSessionAuthChallengeUseCredential;
            } else {
                disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
            }
        } else {
            disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
        }
    }
    
    if (completionHandler) {
        completionHandler(disposition, credential);
    }
}

#pragma mark Helper methods
//这几个方法都是一些辅助的方法，比较好理解

//不同平台计算图片大小方式不同，图片需要缩放一下，读者可以自行查阅源码，很好理解
- (nullable UIImage *)scaledImageForKey:(nullable NSString *)key image:(nullable UIImage *)image {
    return SDScaledImageForKey(key, image);
}

//是否支持后台下载
- (BOOL)shouldContinueWhenAppEntersBackground {
    return self.options & SDWebImageDownloaderContinueInBackground;
}

//调用完成回调块
- (void)callCompletionBlocksWithError:(nullable NSError *)error {
    [self callCompletionBlocksWithImage:nil imageData:nil error:error finished:YES];
}

//遍历所有的完成回调块，在主线程中触发
- (void)callCompletionBlocksWithImage:(nullable UIImage *)image
                            imageData:(nullable NSData *)imageData
                                error:(nullable NSError *)error
                             finished:(BOOL)finished {
    NSArray<id> *completionBlocks = [self callbacksForKey:kCompletedCallbackKey];
    dispatch_main_async_safe(^{
        for (SDWebImageDownloaderCompletedBlock completedBlock in completionBlocks) {
            completedBlock(image, imageData, error, finished);
        }
    });
}