读 SDWebImage 四 (SDWebImageDownloader)

SDWebImage 的图片下载是由 SDWebImageDownloader 这个类实现的，该类是一个异步下载管理器。主要工作是下载相关配置项的管理，包括下载队列的先后顺序、最大下载任务数量控制、下载队列中的任务创建、取消、暂停等任务管理，以及其他的 HTTPS 和 HTTP Header 的设置。而真正实现图片下载的是 SDWebImageDownloaderOperation类。该类的 Operation 操作依赖系统提供的NSURLConnection类来实现图片的下载。

下载选项

枚举列出不同的下载选项 （选项使用掩码形式，如 1 << 2 表示将1左移2位，即：00000010，也就是2。）

typedef NS_OPTIONS(NSUInteger, SDWebImageDownloaderOptions) {

    //默认模式，将下载放入低优先级队列 和 低优先级任务中
    SDWebImageDownloaderLowPriority = 1 << 0,
    
    /**
     * 该选项启用渐进式下载，图像在下载过程中逐步显示，就像浏览器一样。（该选项在返回进度Block的同时也返回completedBlock，里面的UIImage就是当前下载时的图片，可以实现将图片一点点显示出来的功能）
     */
    SDWebImageDownloaderProgressiveDownload = 1 << 1,

    /**
     * 默认情况下，http请求会阻止使用NSURLCache。 使用此标志，NSURLCache将与默认策略一起使用。
     */
    SDWebImageDownloaderUseNSURLCache = 1 << 2,

    /**
     * 如果从NSURLCache缓存中读取图片，则使用nil作为image/imageData的参数来调用block代码块。
     */
    SDWebImageDownloaderIgnoreCachedResponse = 1 << 3,
    
    /**
     * 在iOS 4+ 系统中，允许程序进入后台后继续下载图片，该操作通过向系统申请额外的时间来完成后台下载请求，如果后台任务终止，则操作被取消。
     */
    SDWebImageDownloaderContinueInBackground = 1 << 4,

    /**
     * 通过设置NSMutableURLRequest，HTTPShouldHandleCookies =  YES来处理存储在NSHTTPCookieStore中的cookie;
     */
    SDWebImageDownloaderHandleCookies = 1 << 5,

    /**
     *允许允许不受信任的SSL证书。用于测试目的。 在生产中谨慎使用。
     */
    SDWebImageDownloaderAllowInvalidSSLCertificates = 1 << 6,

    /**
     * 将下载放入高队列优先级和高任务优先级中。
     */
    SDWebImageDownloaderHighPriority = 1 << 7,
    
    /**
     * 缩小图像（默认情况下，图片会按照它的原始大小来解码显示。这个属性会根据设备的内存限制调整图片的尺寸到合适的大小。如果`SDWebImageProgressiveDownload`标记被设置了，则这个flag不起作用。）
     */
    SDWebImageDownloaderScaleDownLargeImages = 1 << 8,
};

下载操作的执行顺序

两种执行顺序： 先进先出 和 后进先出

typedef NS_ENUM(NSInteger, SDWebImageDownloaderExecutionOrder) {
    /**
     * 默认值。 所有下载操作都将以队列样式执行（先进先出）。
     */
    SDWebImageDownloaderFIFOExecutionOrder,

    /**
     * 所有下载操作都将以栈的方式执行（后进先出）。
     */
    SDWebImageDownloaderLIFOExecutionOrder
};

外部定义的系统通知标示

//开始下载通知
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadStartNotification;
//停止下载通知
FOUNDATION_EXPORT NSString * _Nonnull const SDWebImageDownloadStopNotification;

两个代码块

每个下载操作的下载进度回调和下载完成回调，这两个回调稍后将保存在下载管理器的URLCallbacks字典中，key为URL，value为一个数组，数组里面又存放一个保存了下载进度回调和完成回调代码块的字典。

//下载进度代码块
typedef void(^SDWebImageDownloaderProgressBlock)(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL);
//下载完成回调代码块
typedef void(^SDWebImageDownloaderCompletedBlock)(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished);

三个字典

//请求头字典
typedef NSDictionary<NSString *, NSString *> SDHTTPHeadersDictionary;
typedef NSMutableDictionary<NSString *, NSString *> SDHTTPHeadersMutableDictionary;

//自定义请求头，通过Block传值，可以拿到一些参数，然后加工成我们需要的数据，最后返回
typedef SDHTTPHeadersDictionary * _Nullable (^SDWebImageDownloaderHeadersFilterBlock)(NSURL * _Nullable url, SDHTTPHeadersDictionary * _Nullable headers);

SDWebImageDownloadToken

作为下载操作的唯一标识，在创建 operation 的时候初始化绑定，当需要去 cancel 操作的时候就需要这个 token。
SDWebImageDownloadToken 为每一个下载任务的唯一身份标识，SDWebImageDownloader 和我们平时开发中的下载有一些不同，它弱化了下载过程，比较强调的是下载结果，不支持断点下载。

.h文件

@interface SDWebImageDownloadToken : NSObject <SDWebImageOperation>

/**
下载的URL。 这应该是只读的，你不应该修改
 */
@property (nonatomic, strong, nullable) NSURL *url;
/**
 取消token 可以从 “id downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock]” 方法获得，这应该是只读的，你不应该修改。
 @note 使用 `-[SDWebImageDownloadToken cancel]`方法去取消下载token
 */
@property (nonatomic, strong, nullable) id downloadOperationCancelToken;

@end

.m文件

@interface SDWebImageDownloadToken ()

//下载操作
@property (nonatomic, weak, nullable) NSOperation<SDWebImageDownloaderOperationInterface> *downloadOperation;

@end

@implementation SDWebImageDownloadToken

//取消下载
- (void)cancel {
    if (self.downloadOperation) {
        SDWebImageDownloadToken *cancelToken = self.downloadOperationCancelToken;
        if (cancelToken) {
            [self.downloadOperation cancel:cancelToken];
        }
    }
}

@end

SDWebImageDownloader.h文件

属性声明

/**
 * 解压缩下载和缓存的图像可以提高性能，但会占用大量内存。
 * 默认是YES. 如果由于过多的内存消耗而遇到崩溃，可以设置为NO
 */
 //当图片下载完成以后，解码图片。如果因为过多的内存消耗导致一个奔溃，可以把这个属性设置为NO
@property (assign, nonatomic) BOOL shouldDecompressImages;

/**
 * 最大兵法下载数目
 */
@property (assign, nonatomic) NSInteger maxConcurrentDownloads;

/**
 * 显示仍需要下载的当前下载量
 */
@property (readonly, nonatomic) NSUInteger currentDownloadCount;

/**
 *  下载操作的超时值（秒为单位），默认15秒
 */
@property (assign, nonatomic) NSTimeInterval downloadTimeout;

/**
 * 内部NSURLSession使用的配置
 * 直接变换此对象无效
 *
 * @see createNewSessionWithConfiguration:
 */
@property (readonly, nonatomic, nonnull) NSURLSessionConfiguration *sessionConfiguration;

/**
 * 改变下载操作的执行顺序 默认值是 `SDWebImageDownloaderFIFOExecutionOrder`.
 */
@property (assign, nonatomic) SDWebImageDownloaderExecutionOrder executionOrder;

/**
 *  设置要为请求操作设置的默认URL凭据。
 */
@property (strong, nonatomic, nullable) NSURLCredential *urlCredential;

/**
 * 设置用户名
 */
@property (strong, nonatomic, nullable) NSString *username;

/**
 * 设置密码
 */
@property (strong, nonatomic, nullable) NSString *password;

/**
 * 设置过滤器以选择用于下载图像HTTP请求的标头
 *
 * 将为每个下载图像请求调用此块，返回的NSDictionary将用作相应HTTP请求中的标头。
 */
 //http头部的过滤函数
@property (nonatomic, copy, nullable) SDWebImageDownloaderHeadersFilterBlock headersFilter;

方法

//下载管理器单例函数
+ (nonnull instancetype)sharedDownloader;

/**
 * 使用指定的会话配置创建下载程序的实例。（初始化方法）
 * @note `timeoutIntervalForRequest` 将被覆盖
 * @return 下载器的新事例
 */
- (nonnull instancetype)initWithSessionConfiguration:(nullable NSURLSessionConfiguration *)sessionConfiguration NS_DESIGNATED_INITIALIZER;

/**
 * 设置要附加到每个下载HTTP请求的HTTP标头的值。
 *
 * @param value The value for the header field. 值为 `nil` 移除请求头文件.
 * @param field 设置http请求头部字段.
 */
- (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field;

/**
 * 返回指定的HTTP标头字段的值。
 *
 * @return 与标题字段字段关联的值，如果没有相应的标题字段，则为“nil”。
 */
- (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field;

/**
  * 将`SDWebImageDownloaderOperation`的子类设置为默认值
  * 每次SDWebImage构造请求时都要使用`NSOperation`
  * 下载图像的操作。
  *
  * @param operationClass要设置的`SDWebImageDownloaderOperation`的子类
  *默认。 传递`nil`将恢复为`SDWebImageDownloaderOperation`。
  */
- (void)setOperationClass:(nullable Class)operationClass;

/ **
  * 使用给定的URL创建SDWebImageDownloader异步下载器实例
  *
  * 图像完成下载或发生错误时将通知代理。
  *
  * @see SDWebImageDownloaderDelegate
  *
  * @param url要下载的图像的URL
  * @param options用于此下载的选项
  * @param progressBlock在下载图像时重复调用的块
  * @note在后台队列上执行进度块
  * @param completedBlock下载完成后调用的块。
  * 如果下载成功，则设置image参数，如果出错，
  * 错误参数设置为错误。最后一个参数始终为YES
  * 如果没有使用SDWebImageDownloaderProgressiveDownload。随着
  * SDWebImageDownloaderProgressiveDownload选项，调用此块
  * 重复使用部分图像对象，并将完成的参数设置为NO
  * 之前用完整的图像和完成的参数调用最后一次
  * 设为是。如果出错，则完成的参数始终为YES。
  *
  * @return可以传递给-cancel的令牌（SDWebImageDownloadToken）：取消此操作
  * /
- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
                                                   options:(SDWebImageDownloaderOptions)options
                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

/**
 * 取消之前使用排队的下载 获取token使用 “-downloadImageWithURL:options:progress:completed:”方法
 *
 * @param token 从“-downloadImageWithURL:options:progress:completed:”方法获取的token应该被取消
 */
- (void)cancel:(nullable SDWebImageDownloadToken *)token;

/**
 * 设置下载队列挂起状态
 */
- (void)setSuspended:(BOOL)suspended;

/**
 * 取消队列中的所有下载操作
 */
- (void)cancelAllDownloads;

/**
 * 强制SDWebImageDownloader 创建和使用一个给定配置的初始化NSURLSession（队列中的所有现有下载操作都将被取消；请求超时的时间也被重写）
 *
 * @param sessionConfiguration 使用新的NSURLSession配置
 */
- (void)createNewSessionWithConfiguration:(nonnull NSURLSessionConfiguration *)sessionConfiguration;

/**
 * //取消operation并且session设置为Invalidates （如果您使用自定义下载程序而不是共享下载程序，则在不使用它时避免内存泄漏时需要调用此方法）
 * @param cancelPendingOperations 是否取消挂起的操作。
 * @note 在共享下载程序上调用此方法无效。
 */
- (void)invalidateSessionAndCancel:(BOOL)cancelPendingOperations;

SDWebImageDownloader.m文件

属性声明

@interface SDWebImageDownloader () <NSURLSessionTaskDelegate, NSURLSessionDataDelegate>

//下载队列
@property (strong, nonatomic, nonnull) NSOperationQueue *downloadQueue;
//最新添加的操作
@property (weak, nonatomic, nullable) NSOperation *lastAddedOperation;
//操作的类
@property (assign, nonatomic, nullable) Class operationClass;
//下载操作的集合
@property (strong, nonatomic, nonnull) NSMutableDictionary<NSURL *, SDWebImageDownloaderOperation *> *URLOperations;
//HTTP头文件集合
@property (strong, nonatomic, nullable) SDHTTPHeadersMutableDictionary *HTTPHeaders;
//操作锁
@property (strong, nonatomic, nonnull) dispatch_semaphore_t operationsLock; // a lock to keep the access to `URLOperations` thread-safe
//头文件锁
@property (strong, nonatomic, nonnull) dispatch_semaphore_t headersLock; // a lock to keep the access to `HTTPHeaders` thread-safe

// The session in which data tasks will run
//NSURLSession
@property (strong, nonatomic) NSURLSession *session;

@end

初始化方法

SDWebImageDownloader 提供了一个initialize方法 四个初始化方法和一个注销方法

+ (void)initialize {
    //绑定SDNetworkActivityIndicator（如果可用），如果使用它，需要导入"SDNetworkActivityIndicator.h"头文件
    //主要是用来加载图片的时候，状态栏会转小菊花。（该方法是为了给图片下载绑定一个SDNetworkActivityIndicator，只有当这个SDNetworkActivityIndicator文件存在的情况下才会执行，目的就是当下载图片时，状态栏会转小菊花。）
    if (NSClassFromString(@"SDNetworkActivityIndicator")) {

//LLVM 3.0 编译器可以用以下代码消除 warning 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
        id activityIndicator = [NSClassFromString(@"SDNetworkActivityIndicator") performSelector:NSSelectorFromString(@"sharedActivityIndicator")];
#pragma clang diagnostic pop

        // 如果之前已经添加，先移除观察者
        [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStartNotification object:nil];
        [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStopNotification object:nil];
        
        //添加观察者
        [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
                                                 selector:NSSelectorFromString(@"startActivity")
                                                     name:SDWebImageDownloadStartNotification object:nil];
        [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
                                                 selector:NSSelectorFromString(@"stopActivity")
                                                     name:SDWebImageDownloadStopNotification object:nil];
    }
}

//单例，返回SDWebImageDownloader对象
+ (nonnull instancetype)sharedDownloader {
    static dispatch_once_t once;
    static id instance;
    dispatch_once(&once, ^{
        instance = [self new];
    });
    return instance;
}

- (nonnull instancetype)init {
    return [self initWithSessionConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
}

//初始化一个请求对象
- (nonnull instancetype)initWithSessionConfiguration:(nullable NSURLSessionConfiguration *)sessionConfiguration {
    if ((self = [super init])) {
        _operationClass = [SDWebImageDownloaderOperation class];
        _shouldDecompressImages = YES;
        _executionOrder = SDWebImageDownloaderFIFOExecutionOrder;
        _downloadQueue = [NSOperationQueue new];
        _downloadQueue.maxConcurrentOperationCount = 6;
        _downloadQueue.name = @"com.hackemist.SDWebImageDownloader";
        _URLOperations = [NSMutableDictionary new];
#ifdef SD_WEBP
        _HTTPHeaders = [@{@"Accept": @"image/webp,image/*;q=0.8"} mutableCopy];
#else
        _HTTPHeaders = [@{@"Accept": @"image/*;q=0.8"} mutableCopy];
#endif
        _operationsLock = dispatch_semaphore_create(1);
        _headersLock = dispatch_semaphore_create(1);
        _downloadTimeout = 15.0;

        [self createNewSessionWithConfiguration:sessionConfiguration];
    }
    return self;
}

//初始化一个新的请求对象
- (void)createNewSessionWithConfiguration:(NSURLSessionConfiguration *)sessionConfiguration {
    [self cancelAllDownloads];

    if (self.session) {
        [self.session invalidateAndCancel];
    }

    sessionConfiguration.timeoutIntervalForRequest = self.downloadTimeout;

    /**
     *  Create the session for this task
     *  We send nil as delegate queue so that the session creates a serial operation queue for performing all delegate
     *  method calls and completion handler calls.
     */
    self.session = [NSURLSession sessionWithConfiguration:sessionConfiguration
                                                 delegate:self
                                            delegateQueue:nil];
}

///取消operation并且session设置为Invalidates
- (void)invalidateSessionAndCancel:(BOOL)cancelPendingOperations {
    if (self == [SDWebImageDownloader sharedDownloader]) {
        return;
    }
    if (cancelPendingOperations) {
        [self.session invalidateAndCancel];
    } else {
        [self.session finishTasksAndInvalidate];
    }
}

- (void)dealloc {
    [self.session invalidateAndCancel];
    self.session = nil;

    [self.downloadQueue cancelAllOperations];
}

Set 和 Get 方法

//设置请求报文头部
- (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field {
    LOCK(self.headersLock);
    if (value) {
        self.HTTPHeaders[field] = value;
    } else {
        [self.HTTPHeaders removeObjectForKey:field];
    }
    UNLOCK(self.headersLock);
}

//获取请求报文头部
- (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field {
    if (!field) {
        return nil;
    }
    return [[self allHTTPHeaderFields] objectForKey:field];
}

//全部的请求报文头部
- (nonnull SDHTTPHeadersDictionary *)allHTTPHeaderFields {
    LOCK(self.headersLock);
    SDHTTPHeadersDictionary *allHTTPHeaderFields = [self.HTTPHeaders copy];
    UNLOCK(self.headersLock);
    return allHTTPHeaderFields;
}

//设置下载队列的最大并发数
- (void)setMaxConcurrentDownloads:(NSInteger)maxConcurrentDownloads {
    _downloadQueue.maxConcurrentOperationCount = maxConcurrentDownloads;
}

//获取下载队列的当前operation数
- (NSUInteger)currentDownloadCount {
    return _downloadQueue.operationCount;
}

//获取下载队列的最大并发数
- (NSInteger)maxConcurrentDownloads {
    return _downloadQueue.maxConcurrentOperationCount;
}

- (NSURLSessionConfiguration *)sessionConfiguration {
    return self.session.configuration;
}

// 设置一个`SDWebImageDownloaderOperation`的子类作为`NSOperation`来构建request来下载一张图片
- (void)setOperationClass:(nullable Class)operationClass {
    if (operationClass && [operationClass isSubclassOfClass:[NSOperation class]] && [operationClass conformsToProtocol:@protocol(SDWebImageDownloaderOperationInterface)]) {
        _operationClass = operationClass;
    } else {
        _operationClass = [SDWebImageDownloaderOperation class];
    }
}

下载方法

下载管理器的主要实现为 downloadImageWithURL:options:progress:completed: 方法(调用该方法创建 operation 操作)，这个方法调用 - (void)addProgressCallback:completedBlock:forURL: createCallback: 方法来将请求的信息和一些回调函数存入管理器中，同时在创建回调的 block 中创建新 operation 操作,新的操作由管理器中存储的信息配置后，放入到 downloadQueue 操作队列中，最后返回新创建的操作

/**
 下载图片
 @param url 图片url
 @param options 下载选项
 @param progressBlock 下载进度blockhui
 @param completedBlock 下载完成block
 @return  返回一个SDWebImageDownloadToken，用于关联一个请求
    调用addProgressCallback方法 return token，addProgressCallback的回调里进行以下操作
    {
        1.1设置下载时间
        1.2创建request
        1.3创建operation对象 传入 request session options
        1.4设置身份认证
        1.5设置下载优先级
        1.6设置下载顺序
    }

 */
- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
                                                   options:(SDWebImageDownloaderOptions)options
                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
    __weak SDWebImageDownloader *wself = self;
    // 调用- (void)addProgressCallback:completedBlock:forURL: createCallback:方法来将请求的信息和一些回调函数存入管理器中，同时在创建回调的block中创建新operation操作,新的操作由管理器中存储的信息配置后，放入到downloadQueue操作队列中，最后返回新创建的操作
    return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
        __strong __typeof (wself) sself = wself;
        //获取超时时间，如果没有设置，默认为15秒
        NSTimeInterval timeoutInterval = sself.downloadTimeout;
        if (timeoutInterval == 0.0) {
            timeoutInterval = 15.0;
        }

        // 为了防止潜在的重复缓存（NSURLCache 和 SDImageCache同时缓存），如果另有说明，我们会禁用图像请求的缓存
        NSURLRequestCachePolicy cachePolicy = options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData;
        
        //创建请求对象，并根据options参数设置其属性
        NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url
                                                                    cachePolicy:cachePolicy
                                                                timeoutInterval:timeoutInterval];
        
        //使用cookies
        request.HTTPShouldHandleCookies = (options & SDWebImageDownloaderHandleCookies);
        //使用管道
        request.HTTPShouldUsePipelining = YES;
        //添加自定义请求头
        if (sself.headersFilter) {
            request.allHTTPHeaderFields = sself.headersFilter(url, [sself allHTTPHeaderFields]);
        }
        else {
            request.allHTTPHeaderFields = [sself allHTTPHeaderFields];
        }
        //初始化一个自定义NSOperation对象
        SDWebImageDownloaderOperation *operation = [[sself.operationClass alloc] initWithRequest:request inSession:sself.session options:options];
        //当图片下载完成以后，解码图片。如果因为过多的内存消耗导致一个奔溃，可以把这个属性设置为NO
        operation.shouldDecompressImages = sself.shouldDecompressImages;
        
        //指定验证信息（url证书）
        if (sself.urlCredential) {
            operation.credential = sself.urlCredential;
        } else if (sself.username && sself.password) {
            //基础验证
            operation.credential = [NSURLCredential credentialWithUser:sself.username password:sself.password persistence:NSURLCredentialPersistenceForSession];
        }
        
        //指定优先级
        if (options & SDWebImageDownloaderHighPriority) {
            operation.queuePriority = NSOperationQueuePriorityHigh;
        } else if (options & SDWebImageDownloaderLowPriority) {
            operation.queuePriority = NSOperationQueuePriorityLow;
        }
        
        //指定下载顺序（ 如果是LIFO这种模式，则需要手动指定operation之间的依赖关系）
        if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
            // 如果是LIFO，则让前面的operation依赖于最新添加的operation
            [sself.lastAddedOperation addDependency:operation];
            sself.lastAddedOperation = operation;
        }

        return operation;
    }];
}

//取消一个图片的下载操作
- (void)cancel:(nullable SDWebImageDownloadToken *)token {
    //如果url不存在，则返回
    NSURL *url = token.url;
    if (!url) {
        return;
    }
    //获取该操作，通过token来确定操作是否取消（移除），如果取消，则在URLOperations中移除url
    LOCK(self.operationsLock);
    SDWebImageDownloaderOperation *operation = [self.URLOperations objectForKey:url];
    if (operation) {
        BOOL canceled = [operation cancel:token.downloadOperationCancelToken];
        if (canceled) {
            [self.URLOperations removeObjectForKey:url];
        }
    }
    UNLOCK(self.operationsLock);
}

//给下载过程添加进度
/**
    1.生成URLOperations字典 下载url作为key value是具体的下载operation
    2.将操作添加到操作队列中
    3.将进度progressBlock和下载结束completedBlock封装成字典SDCallbacksDictionary，装入数组callbackBlocks，
    4.生成token标识，并返回token
*/
- (nullable SDWebImageDownloadToken *)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock
                                           completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock
                                                   forURL:(nullable NSURL *)url
                                           createCallback:(SDWebImageDownloaderOperation *(^)(void))createCallback {
    // url作为回调字典里的key，因此url不能为空，如果url为空则立即调用已完成代码块（image、imageData都传nil），并直接返回
    if (url == nil) {
        if (completedBlock != nil) {
            completedBlock(nil, nil, nil, NO);
        }
        return nil;
    }
    
    LOCK(self.operationsLock);
    获取url下载的操作
    SDWebImageDownloaderOperation *operation = [self.URLOperations objectForKey:url];
    // 有一种情况是操作可能被标记为已完成，但未从“self.URLOperations”中删除。
    if (!operation || operation.isFinished) {
    //创建一个operation，并且添加到URLOperation中
        operation = createCallback();
        __weak typeof(self) wself = self;
        
        //设置operation操作完成以后的回调
        operation.completionBlock = ^{
            __strong typeof(wself) sself = wself;
            if (!sself) {
                return;
            }
            LOCK(sself.operationsLock);
            //完成以后从URLOperations中移除该URL的operation操作
            [sself.URLOperations removeObjectForKey:url];
            UNLOCK(sself.operationsLock);
        };
        
        //将该url的operation操作添加到URLOperations中
        [self.URLOperations setObject:operation forKey:url];

        //仅在根据Apple的doc完成所有配置后才将操作添加到操作队列。`addOperation：`不同步执行`operation.completionBlock`，所以这不会导致死锁。
        //把operation添加进入NSOperationQueue中，当operation添加到downloadQueue，会触发相应的start方法，开始下载。
        [self.downloadQueue addOperation:operation];
    }
    UNLOCK(self.operationsLock);

    //获取downloadOperationCancelToken
    id downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock];
    
    //创建一个新的token，给各属性赋值，并返回token
    SDWebImageDownloadToken *token = [SDWebImageDownloadToken new];
    token.downloadOperation = operation;
    token.url = url;
    token.downloadOperationCancelToken = downloadOperationCancelToken;

    return token;
}

//设置下载队列全部暂停/开始
- (void)setSuspended:(BOOL)suspended {
    self.downloadQueue.suspended = suspended;
}

//全部取消下载队列中的下载操作
- (void)cancelAllDownloads {
    [self.downloadQueue cancelAllOperations];
}


#pragma mark Helper methods
//根据task获取下载操作operation
- (SDWebImageDownloaderOperation *)operationWithTask:(NSURLSessionTask *)task {
    SDWebImageDownloaderOperation *returnOperation = nil;
    for (SDWebImageDownloaderOperation *operation in self.downloadQueue.operations) {
        if (operation.dataTask.taskIdentifier == task.taskIdentifier) {
            returnOperation = operation;
            break;
        }
    }
    return returnOperation;
}

NSURLSessionDataDelegate

当收到数据的时候，会触发这些代理方法，最后调用SDWebImageDownloaderOperation中的代理方法，来实际处理事情。

- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
didReceiveResponse:(NSURLResponse *)response
 completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {

    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
    if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:didReceiveResponse:completionHandler:)]) {
        [dataOperation URLSession:session dataTask:dataTask didReceiveResponse:response completionHandler:completionHandler];
    } else {
        if (completionHandler) {
            completionHandler(NSURLSessionResponseAllow);
        }
    }
}

- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {

    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
    if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:didReceiveData:)]) {
        [dataOperation URLSession:session dataTask:dataTask didReceiveData:data];
    }
}

- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
 willCacheResponse:(NSCachedURLResponse *)proposedResponse
 completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler {

    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
    if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:willCacheResponse:completionHandler:)]) {
        [dataOperation URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler];
    } else {
        if (completionHandler) {
            completionHandler(proposedResponse);
        }
    }
}

NSURLSessionTaskDelegate

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
    
    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
    if ([dataOperation respondsToSelector:@selector(URLSession:task:didCompleteWithError:)]) {
        [dataOperation URLSession:session task:task didCompleteWithError:error];
    }
}

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler {
    
    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
    if ([dataOperation respondsToSelector:@selector(URLSession:task:willPerformHTTPRedirection:newRequest:completionHandler:)]) {
        [dataOperation URLSession:session task:task willPerformHTTPRedirection:response newRequest:request completionHandler:completionHandler];
    } else {
        if (completionHandler) {
            completionHandler(request);
        }
    }
}

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler {

    // Identify the operation that runs this task and pass it the delegate method
    SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
    if ([dataOperation respondsToSelector:@selector(URLSession:task:didReceiveChallenge:completionHandler:)]) {
        [dataOperation URLSession:session task:task didReceiveChallenge:challenge completionHandler:completionHandler];
    } else {
        if (completionHandler) {
            completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil);
        }
    }
}