SDWebImage源码阅读(八)SDWebImageDownloaderOperation(下)

　　上篇主要对 NSOperation 进行了拓展学习，下面开始着重学习 SDWebImageDownloaderOperation。

　　通知

extern NSString * _Nonnull const SDWebImageDownloadStartNotification;
extern NSString * _Nonnull const SDWebImageDownloadReceiveResponseNotification;
extern NSString * _Nonnull const SDWebImageDownloadStopNotification;
extern NSString * _Nonnull const SDWebImageDownloadFinishNotification;

　　这 4 个不可变字符串，分别表示：开始下载、接收到数据、停止、完成的通知。

　　SDWebImageDownloaderOperationInterface 

/**
 Describes a downloader operation. If one wants to use a custom downloader op, it needs to inherit from `NSOperation` and conform to this protocol
 */
@protocol SDWebImageDownloaderOperationInterface<NSObject>

- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
                              inSession:(nullable NSURLSession *)session
                                options:(SDWebImageDownloaderOptions)options;

- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

- (BOOL)shouldDecompressImages;
- (void)setShouldDecompressImages:(BOOL)value;

- (nullable NSURLCredential *)credential;
- (void)setCredential:(nullable NSURLCredential *)value;

@end

　　描述一个下载操作，如果你想使用一个自定义的下载操作，就需要继承 NSOperation 并且遵守 SDWebImageDownloaderOperationInterface 协议。

　　6 个代理方法：

　　1.使用 NSURLRequest 、NSURLSession 、SDWebImageDownloaderOptions 初始化一个 SDWebImageDownloaderOperation 对象。

　　2.添加下载进度和下载完成的 block。

　　3.是否解压图像的 setter 和 getter 方法。

　　4.是否需要设置凭证的 setter 和 getter 方法。

　　SDWebImageDownloaderOperation

@interface SDWebImageDownloaderOperation : NSOperation <SDWebImageDownloaderOperationInterface, SDWebImageOperation, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>

　　SDWebImageDownloaderOperation 遵守 SDWebImageDownloaderOperationInterface 、SDWebImageOperation 、NSURLSessionTaskDelegate 、NSURLSessionDataDelegate 协议，首先是上面的 6 个代理方法都要实现。在设计这个 .h 的时候，可以把协议中的方法再次写入这个 .h 中，这样在使用的时候会更加直观。

@property (assign, nonatomic) BOOL shouldDecompressImages;

/**
 * The credential used for authentication challenges in `-connection:didReceiveAuthenticationChallenge:`.
 *
 * This will be overridden by any shared credentials that exist for the username or password of the request URL, if present.
 */
@property (nonatomic, strong, nullable) NSURLCredential *credential;

　　通过声明这两个属性，就实现了 SDWebImageDownloaderOperationInterface 协议中的对应的 setter 和 getter 方法对应的代理方法。

　　一般情况下，如果主动指明类的初始化方法，那么肯定会为初始化方法设定几个参数。

　　那么这些参数就应该以只读的方式暴露出来。

　　指定初始化方法：

/**
 *  Initializes a `SDWebImageDownloaderOperation` object
 *
 *  @see SDWebImageDownloaderOperation
 *
 *  @param request        the URL request
 *  @param session        the URL session in which this operation will run
 *  @param options        downloader options
 *
 *  @return the initialized instance
 */
- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
                              inSession:(nullable NSURLSession *)session
                                options:(SDWebImageDownloaderOptions)options NS_DESIGNATED_INITIALIZER;

　　只读的属性:

/**
 * The request used by the operation's task.
 */
@property (strong, nonatomic, readonly, nullable) NSURLRequest *request;

/**
 * The operation's task
 */
@property (strong, nonatomic, readonly, nullable) NSURLSessionTask *dataTask;

/**
 * The SDWebImageDownloaderOptions for the receiver.
 */
@property (assign, nonatomic, readonly) SDWebImageDownloaderOptions options;

　　其它的属性:

/**
 * The expected size of data.
 */
@property (assign, nonatomic) NSInteger expectedSize;

/**
 * The response returned by the operation's connection.
 */
@property (strong, nonatomic, nullable) NSURLResponse *response;

　　表示数据预期的大小和操作连接返回的响应。

　　返回用于取消此处理程序集的标记 和 取消操作

/**
 *  Adds handlers for progress and completion. Returns a tokent that can be passed to -cancel: to cancel this set of
 *  callbacks.
 *
 *  @param progressBlock  the block executed when a new chunk of data arrives.
 *                        @note the progress block is executed on a background queue
 *  @param completedBlock the block executed when the download is done.
 *                        @note the completed block is executed on the main queue for success. If errors are found, there is a chance the block will be executed on a background queue
 *
 *  @return the token to use to cancel this set of handlers
 */
- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

/**
 *  Cancels a set of callbacks. Once all callbacks are canceled, the operation is cancelled.
 *
 *  @param token the token representing a set of callbacks to cancel
 *
 *  @return YES if the operation was stopped because this was the last token to be canceled. NO otherwise.
 */
- (BOOL)cancel:(nullable id)token;

　　这个方法不是取消任务的，而是取消任务中的响应，当任务中没有响应者的时候，任务会被取消。

　　SDWebImageDownloaderOperation.m

NSString *const SDWebImageDownloadStartNotification = @"SDWebImageDownloadStartNotification";
NSString *const SDWebImageDownloadReceiveResponseNotification = @"SDWebImageDownloadReceiveResponseNotification";
NSString *const SDWebImageDownloadStopNotification = @"SDWebImageDownloadStopNotification";
NSString *const SDWebImageDownloadFinishNotification = @"SDWebImageDownloadFinishNotification";

　　4 个不可变的通知的字符串的初始化。

static NSString *const kProgressCallbackKey = @"progress";
static NSString *const kCompletedCallbackKey = @"completed";

　　定义两个静态不可变的字符串，表示下载进度回调的 key 和下载完成的回调的 key。

typedef NSMutableDictionary<NSString *, id> SDCallbacksDictionary;

　　定义一个 key 是字符串 value 是 id 的可变的字典类型。（ SDCallbacksDictionary）

@interface SDWebImageDownloaderOperation ()

@property (strong, nonatomic, nonnull) NSMutableArray<SDCallbacksDictionary *> *callbackBlocks;

@property (assign, nonatomic, getter = isExecuting) BOOL executing;
@property (assign, nonatomic, getter = isFinished) BOOL finished;
@property (strong, nonatomic, nullable) NSMutableData *imageData;

// This is weak because it is injected by whoever manages this session. If this gets nil-ed out, we won't be able to run
// the task associated with this operation
@property (weak, nonatomic, nullable) NSURLSession *unownedSession;
// This is set if we're using not using an injected NSURLSession. We're responsible of invalidating this one
@property (strong, nonatomic, nullable) NSURLSession *ownedSession;

@property (strong, nonatomic, readwrite, nullable) NSURLSessionTask *dataTask;

@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t barrierQueue;

#if SD_UIKIT
@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundTaskId;
#endif

@end

@implementation SDWebImageDownloaderOperation {
    size_t width, height;
#if SD_UIKIT || SD_WATCH
    UIImageOrientation orientation;
#endif
    BOOL responseFromCached;
}

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

 　　callbackBlocks 是一个可变数组，数组里面存放的是  SDCallbacksDictionary，这是上面定义的一个可变字典的类型。这个字典的 key 是字符串，这个字符串有种情况，就是上面定义的两个静态不可变字符串：kProgressCallbackKey 和 kCompletedCallbackKey，也就是说进度和完成的回调都放在一个数组里，字典的 value 就是回调的 block。

　　unownedSession 这个属性是初始化时候传进来的参数，作者提到，这个参数不一定是可用的，也就是说是不安全的，当出现不可用的情况的时候，就需要使用 ownedSession。

　　responseFromCached  用于设置是否需要缓存响应，默认是 YES。 

　　barrierQueue 是一个 GCD 队列。

　　backgroundTaskId 是在 app 进入后台后申请的后台任务的身份。 

　　初始化一个任务 

- (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;
        responseFromCached = YES; // Initially wrong until `- URLSession:dataTask:willCacheResponse:completionHandler: is called or not called
        _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 {
    SDCallbacksDictionary *callbacks = [NSMutableDictionary new];
    if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
    if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
    dispatch_barrier_async(self.barrierQueue, ^{
        [self.callbackBlocks addObject:callbacks];
    });
    return callbacks;
}

　　把指定 key 和 指定 value 的字典添加到 _callbackBlocks 数组。

　　dispatch_barrier_async

　　我们可以创建两种类型的队列，串行和并行，也就是：

　　DISPATCH_QUEUE_SERIAL 、DISPATCH_QUEUE_CONCURRENT。那么 dispatch_barrier_async 和dispatch_barrier_sync 有什么不同之处：

　　barrier 这个词是栅栏的意思，也就是说是用来做拦截功能的，上边的这两种都能够拦截任务，换句话说，就是只有当前任务完成后，队列后边的任务才能完成。

　　不同之处就是，dispatch_barrier_sync 控制了任务往队列添加这一过程，只有当前任务完成之后，才能往队列中添加任务。dispatch_barrier_async 不会控制队列添加任务，但是只有当前任务完成后，队列中后边的任务才会执行。

　　那么在这里的任务是往数组中添加数据，对顺序没什么要求，采取 dispatch_barrier_async 就可以，已经能保证数据添加的安全性了。

 

- (nullable NSArray<id> *)callbacksForKey:(NSString *)key {
    __block NSMutableArray<id> *callbacks = nil;
    dispatch_sync(self.barrierQueue, ^{
        // We need to remove [NSNull null] because there might not always be a progress block for each callback
        callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];
        [callbacks removeObjectIdenticalTo:[NSNull null]];
    });
    return [callbacks copy];    // strip mutability here
}

　　我们需要删除 [NSNull null]，因为每次回调可能不总是有一个回调 block。

　　在 self.barrierQueue 队列里面同步执行。

　　self.callbackBlocks 是一个数组，但是这里从数组里面取 block 采用了：

callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];

@interface NSDictionary<KeyType, ObjectType>(NSKeyValueCoding)

/* Return the result of sending -objectForKey: to the receiver.
*/
- (nullable ObjectType)valueForKey:(NSString *)key;

@end

　　假定 self.callbackBlocks 的结构是这样的:

@[@{@"completed" : Block1}, 
@{@"progress" : Block2}, 
@{@"completed" : Block3}, 
@{@"progress" : Block4}, 
@{@"completed" : Block5}, 
@{@"progress" : Block6}]

 　　那么得到的如果 key 是 @"progress" 则 callbacks 就是 [Block2, Block4, Block6]。

- (void)removeObjectIdenticalTo:(ObjectType)anObject;

　　这个方法会移除数组中和 anObject 相同地址的元素。

[callbacks removeObjectIdenticalTo:[NSNull null]];

　　移除 callbacks 里面的 [NSNull null]。

- (BOOL)cancel:(nullable id)token {
    __block BOOL shouldCancel = NO;
    dispatch_barrier_sync(self.barrierQueue, ^{
        [self.callbackBlocks removeObjectIdenticalTo:token];
        if (self.callbackBlocks.count == 0) {
            shouldCancel = YES;
        }
    });
    if (shouldCancel) {
        [self cancel];
    }
    return shouldCancel;
}

　　 布尔 shouldCancel 表示是否取消操作。

　　在 self.barrierQueue 同步删除 self.callbackBlocks 里面的指定回调。（typedef NSMutableDictionary<NSString *, id> SDCallbacksDictionary;）

　　当 self.callbackBlocks 里面的回调删除完的时候，取消操作。

　　开启下载任务

- (void)start {
    @synchronized (self) {
        if (self.isCancelled) {
            self.finished = YES;
            [self reset];
            return;
        }

#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
        NSURLSession *session = self.unownedSession;
        if (!self.unownedSession) {
            NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
            sessionConfig.timeoutIntervalForRequest = 15;
            
            /**
             *  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.ownedSession = [NSURLSession sessionWithConfiguration:sessionConfig
                                                              delegate:self
                                                         delegateQueue:nil];
            session = self.ownedSession;
        }
        
        self.dataTask = [session dataTaskWithRequest:self.request];
        self.executing = YES;
    }
    
    [self.dataTask resume];

    if (self.dataTask) {
        for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
            progressBlock(0, NSURLResponseUnknownLength, self.request.URL);
        }
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:self];
        });
    } else {
        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Connection can't be initialized"}]];
    }

#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
}

　　开启下载任务，首先判断该任务是否已经被设置取消了，如果被设置取消了，那么就不需要开启下载任务了，并重置，并设置 finished 为 YES（通过 KVO 设置）。

- (void)setFinished:(BOOL)finished {
    [self willChangeValueForKey:@"isFinished"];
    _finished = finished;
    [self didChangeValueForKey:@"isFinished"];
}

 

　　重置操作：

- (void)reset {
    dispatch_barrier_async(self.barrierQueue, ^{
        [self.callbackBlocks removeAllObjects];
    });
    self.dataTask = nil;
    self.imageData = nil;
    if (self.ownedSession) {
        [self.ownedSession invalidateAndCancel];
        self.ownedSession = nil;
    }
}

　　

　　是否开启后台下载任务

　　条件 1:

　　判断 self.options （下载设置）是否在 app 进入后台后继续未完成的下载（如果后台任务过期，操作将被取消）：

- (BOOL)shouldContinueWhenAppEntersBackground {
    return self.options & SDWebImageDownloaderContinueInBackground;
}

    /**
     * In iOS 4+, continue the download of the image if the app goes to background. This is achieved by asking the system for
     * extra time in background to let the request finish. If the background task expires the operation will be cancelled.
     */

    SDWebImageDownloaderContinueInBackground = 1 << 4,

　　把 self.options 和 SDWebImageDownloaderContinueInBackground 做与操作。返回 YES 或 NO 判断是否需要在 app 进入后台后申请继续未完成的下载操作。 

 　　条件 2：

 　　如果当前是 iOS 或 TV 平台开发，先判断是否有 UIApplication 类 和 UIApplication 类是否有 sharedAppliction 方法实现。

　　如果上述条件都成立，通过 UIApplication 类向系统申请更多的后台处理时间，去进行未完成的图片下载。

 

　　下面进行当 app 进入后台的时候主动申请进行更长时间的后台操作的方法进行拓展学习：

　　当 app 进入后台的时候（按 Home 键 app 退出，回到手机主界面的时候），会执行 UIApplicationDelegate 的进入后台的代理方法：

- (void)applicationDidEnterBackground:(UIApplication *)application {
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.

    // 输入自定义代码
    
    }

　　当应用程序进入后台后，它的主线程会被暂停。

　　当应用程序从前台进入后台，应用程序会调用 applicationDidEnterBackground 代理方法，这个时候应用程序会给几秒的时间处理东西，然后把所有的线程挂起。

　　在开发过程中，可能需要更长的时间完成应用程序进入后台的操作，例如把数据保存到本地或者保存到服务器等操作。系统给的时间太短，这个时候就需要向应用程序申请更长的时间进行后台操作。

　　如果想在后台完成一个长期的任务，就必须调用 UIApplication 的 beginBackgroundTaskWithExpirationHandler: 实例方法，向 iOS 系统借些 app 的运行时间。

　　向 iOS 系统借时间的步骤:

　　在 AppDelegate.h 中声明一个 UIBackgroundTaskIdentifier 变量：

@property (nonatomic, unsafe_unretained) UIBackgroundTaskIdentifier backgroundTaskIdentifier;
@property (strong, nonatomic) NSTimer *myTimer;

typedef NSUInteger UIBackgroundTaskIdentifier;

　　在 AppDelegate.m 文件中：

　　判断当前设备是否支持后台多任务:

- (BOOL)isMutiltaskingSupported {
    BOOL result = NO;
    if ([[UIDevice currentDevice] respondsToSelector:@selector(isMutiltaskingSupported)]) {
        result = [[UIDevice currentDevice] isMultitaskingSupported];
    }
    return result;
}

　　结束后台任务:

- (void)endBackgroundTask {
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    __weak AppDelegate *weakSelf = self;
    dispatch_async(mainQueue, ^{
        __strong AppDelegate *strongSelf = weakSelf;
        if (strongSelf != nil) {
            [strongSelf.myTimer invalidate]; // 停止定时器
            
            // 每个对 beginBackgroundTaskWithExpirationHandler: 方法的调用，必须相应的调用 endBackgroundTask: 方法，这样来告诉应用程序，前面申请的后台任务已经执行完毕了
            // 也就是说，向 iOS 系统要更多的时间来完成一个任务，那么必须告诉 iOS 系统什么时候能完成这个后台任务
            // 标记指定的后台任务完成
            [[UIApplication sharedApplication] endBackgroundTask:strongSelf.backgroundTaskIdentifier];
            // 销毁后台任务标识符
            strongSelf.backgroundTaskIdentifier = UIBackgroundTaskInvalid;
        }
    });
}

　　重点 applicationDidEnterBackground :

- (void)applicationDidEnterBackground:(UIApplication *)application {
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
    
    // 当 app 进入后台的时候，释放公共的资源、存储用户数据、停止定义的定时器、存储程序终止前的相关信息
    // 如果应用程序提供了后台执行的方法，那么在程序退出时，这个方法将代替 applicationWillTerminate: 方法执行
    
    if ([self isMutiltaskingSupported] == NO) {
        NSLog(@"---> 不支持后台任务");
        return;
    }
    
    // 标记一个长时间运行的后台任务将开始
    // 调试发现，iOS 系统给了额外的3分钟来执行这个任务，在 iOS 7 以前，后台可以用下面的的方式，去在后台存活 5-10 分钟，在 iOS 8 后，只能存活3分钟
    self.backgroundTaskIdentifier = [application beginBackgroundTaskWithExpirationHandler:^{
        // 当应用程序留给后台的时间快要结束时（应用程序留给后台执行的时间是有限的），这个 block 就会被执行
        // 需要在这个 block 中执行一些清理工作
        
        // 清理工作需要在主线程中用同步的方式进行
        [self endBackgroundTask];
    }];

    // 下面的定时器模拟一个需要长时间才能运行结束的后台任务
    self.myTimer = [NSTimer scheduledTimerWithTimeInterval:1.f
                                                    target:self
                                                  selector:@selector(timerMethod:)
                                                  userInfo:nil
                                                   repeats:YES];
    
}

　　定时器调用方法:

- (void)timerMethod:(NSTimer *)paramSender {
    // backgroundTimeRemaining 属性包含了程序留给后台执行任务的时间
    NSTimeInterval backgroundTimeRemaining = [[UIApplication sharedApplication] backgroundTimeRemaining];
    if (backgroundTimeRemaining == DBL_MAX) {
        NSLog(@"Background Time Remaining = Undeterminded");
    }
    // 显示后台任务还剩余的时间
    NSLog(@"Background Timer Remaining = %.2f seconds", backgroundTimeRemaining);
}

　　控制台打印:

2017-06-05 07:28:41.652 NSOperation_DEMO[28232:941126] Background Timer Remaining = 179.00 seconds
2017-06-05 07:28:42.651 NSOperation_DEMO[28232:941126] Background Timer Remaining = 178.00 seconds
2017-06-05 07:28:43.652 NSOperation_DEMO[28232:941126] Background Timer Remaining = 177.00 seconds
2017-06-05 07:28:44.650 NSOperation_DEMO[28232:941126] Background Timer Remaining = 176.00 seconds
2017-06-05 07:28:45.651 NSOperation_DEMO[28232:941126] Background Timer Remaining = 175.00 seconds
2017-06-05 07:28:46.652 NSOperation_DEMO[28232:941126] Background Timer Remaining = 174.00 seconds
7 ......

　　如果任务提前结束了，可以直接调用结束后台任务的方法。

　　当应用程序回到了前台，如果后台任务还在执行中，可以在 applicationWillEnterForeground: 中终止它:

- (void)applicationWillEnterForeground:(UIApplication *)application {
    // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
    if (self.backgroundTaskIdentifier != UIBackgroundTaskInvalid) {
        [self endBackgroundTask];
    }
}

　　在 iOS 申请，在后台无限时间进行后台任务：

　　在后台用 AVAudioPlayer 无限循环播放一个无声的音频文件。

　　并对 Background Modes 进行设置：

　　

 

　　下面接着往下看开启下载任务的代码:

　　当向 iOS 系统申请的后台运行时间结束的时候在：

- (UIBackgroundTaskIdentifier)beginBackgroundTaskWithExpirationHandler:(void(^ __nullable)(void))handler  NS_AVAILABLE_IOS(4_0) NS_REQUIRES_SUPER;

　　的 block 里调用 cancel 方法: 　　

- (void)cancel {
    @synchronized (self) {
        [self cancelInternal];
    }
}

- (void)cancelInternal {
    if (self.isFinished) return;
    [super cancel];

    if (self.dataTask) {
        [self.dataTask cancel];
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:self];
        });

        // As we cancelled the connection, its callback won't be called and thus won't
        // maintain the isFinished and isExecuting flags.
        if (self.isExecuting) self.executing = NO;
        if (!self.isFinished) self.finished = YES;
    }

    [self reset];
}

　　如果 self.isFinished 为真，即下载任务已经完成，直接 return，如果下载任务没有完成，但是申请的后台任务时间（3 分钟）已经到了，则手动结束下载任务。

　　@synchronized (self) { } 的作用是创建一个互斥锁，保证在同一个时间内没有其它线程对 self 对象进行修改，起到线程的保护作用，一般在公用变量的时候使用，如单例模式或者操作类的 static 变量中使用。

 　　如果 self.unownedSession  不存在，则创建一个超时为 15 秒的 NSURLSession 实例赋值给 self.ownedSession。

　　self.request 做参数，创建一个 NSURLSessionDataTask 实例，并赋值给 self.dataTask。NSOperation 的 

 的 executing 设置为 YES（通过 KVO 设置）。

- (void)setExecuting:(BOOL)executing {
    [self willChangeValueForKey:@"isExecuting"];
    _executing = executing;
    [self didChangeValueForKey:@"isExecuting"];
}

　　开始执行 self.dataTask。

　　如果 self.dataTask 存在，遍历 self.callbackBlocks 先执行第一个进度的 block。

- (nullable NSArray<id> *)callbacksForKey:(NSString *)key {
    __block NSMutableArray<id> *callbacks = nil;
    dispatch_sync(self.barrierQueue, ^{
        // We need to remove [NSNull null] because there might not always be a progress block for each callback
        callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];
        [callbacks removeObjectIdenticalTo:[NSNull null]];
    });
    return [callbacks copy];    // strip mutability here
}

　　在主线程发送一个名为 SDWebImageDownloadStartNotification 的通知。

　　如果 self.dataTask 不存在：

        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Connection can't be initialized"}]];

- (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);
        }
    });
}

　　 做 block 回调。

　　在往下是不等到申请的后台任务时间结束（3 分钟）就手动结束后台任务。

 

　　NSURLSessionDataDelegate

- (void)URLSession:(NSURLSession *)session
          dataTask:(NSURLSessionDataTask *)dataTask
didReceiveResponse:(NSURLResponse *)response
 completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
    
    //'304 Not Modified' is an exceptional one
    if (![response respondsToSelector:@selector(statusCode)] || (((NSHTTPURLResponse *)response).statusCode < 400 && ((NSHTTPURLResponse *)response).statusCode != 304)) {
        NSInteger expected = response.expectedContentLength > 0 ? (NSInteger)response.expectedContentLength : 0;
        self.expectedSize = expected;
        for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
            progressBlock(0, expected, self.request.URL);
        }
        
        self.imageData = [[NSMutableData alloc] initWithCapacity:expected];
        self.response = response;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadReceiveResponseNotification object:self];
        });
    }
    else {
        NSUInteger code = ((NSHTTPURLResponse *)response).statusCode;
        
        //This is the case when server returns '304 Not Modified'. It means that remote image is not changed.
        //In case of 304 we need just cancel the operation and return cached image from the cache.
        if (code == 304) {
            [self cancelInternal];
        } else {
            [self.dataTask cancel];
        }
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:self];
        });
        
        [self callCompletionBlocksWithError:[NSError errorWithDomain:NSURLErrorDomain code:((NSHTTPURLResponse *)response).statusCode userInfo:nil]];

        [self done];
    }
    
    if (completionHandler) {
        completionHandler(NSURLSessionResponseAllow);
    }
}

　　当收到响应的时候执行的代理方法。当没有收到响应码或者响应码小于 400 且响应码不是 304 的时候，认定为正常的响应。304 比较特殊，当响应码是 304 的时候，表示这个响应没有变化，可以在缓存中读取。响应码是其它的情况的时候就表示为错误的请求。

　　当响应正常的时候，给 self.expectedSize 赋值，执行 self.callbackBlocks 里面表示进度的回调 block，给 self.imageData 根据 expectedSize 的大小初始化，把 response  赋值给 self.response，异步调取主线程发送 SDWebImageDownloadReceiveResponseNotification 通知。

　　当以上情况都排除，响应不正常的时候，如果服务器返回的响应码是 "304未修改" 的情况，表示远程图像没有改变，对于 304 的情况只需要取消操作，并从缓存返回缓存的图像。

　　如果状态码是 304 调用 cancelInternal 方法。

　　如果不是 304，self.dataTask 调用 cancel。

　　调取主线程发送 SDWebImageDownloadStopNotification 通知。

　　调用 callCompletionBlocksWithError: 方法，携带错误信息回调。

　　调用 done 方法。 

- (void)done {
    self.finished = YES;
    self.executing = NO;
    [self reset];
}

　　最后执行 completionHandler。

- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {
    [self.imageData appendData:data];

    if ((self.options & SDWebImageDownloaderProgressiveDownload) && self.expectedSize > 0) {
        // The following code is from http://www.cocoaintheshell.com/2011/05/progressive-images-download-imageio/
        // Thanks to the author @Nyx0uf

        // Get the total bytes downloaded
        const NSInteger totalSize = self.imageData.length;

        // Update the data source, we must pass ALL the data, not just the new bytes
        CGImageSourceRef imageSource = CGImageSourceCreateWithData((__bridge CFDataRef)self.imageData, NULL);

        if (width + height == 0) {
            CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, NULL);
            if (properties) {
                NSInteger orientationValue = -1;
                CFTypeRef val = CFDictionaryGetValue(properties, kCGImagePropertyPixelHeight);
                if (val) CFNumberGetValue(val, kCFNumberLongType, &height);
                val = CFDictionaryGetValue(properties, kCGImagePropertyPixelWidth);
                if (val) CFNumberGetValue(val, kCFNumberLongType, &width);
                val = CFDictionaryGetValue(properties, kCGImagePropertyOrientation);
                if (val) CFNumberGetValue(val, kCFNumberNSIntegerType, &orientationValue);
                CFRelease(properties);

                // When we draw to Core Graphics, we lose orientation information,
                // which means the image below born of initWithCGIImage will be
                // oriented incorrectly sometimes. (Unlike the image born of initWithData
                // in didCompleteWithError.) So save it here and pass it on later.
#if SD_UIKIT || SD_WATCH
                orientation = [[self class] orientationFromPropertyValue:(orientationValue == -1 ? 1 : orientationValue)];
#endif
            }
        }

        if (width + height > 0 && totalSize < self.expectedSize) {
            // Create the image
            CGImageRef partialImageRef = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);

#if SD_UIKIT || SD_WATCH
            // Workaround for iOS anamorphic image
            if (partialImageRef) {
                const size_t partialHeight = CGImageGetHeight(partialImageRef);
                CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
                CGContextRef bmContext = CGBitmapContextCreate(NULL, width, height, 8, width * 4, colorSpace, kCGBitmapByteOrderDefault | kCGImageAlphaPremultipliedFirst);
                CGColorSpaceRelease(colorSpace);
                if (bmContext) {
                    CGContextDrawImage(bmContext, (CGRect){.origin.x = 0.0f, .origin.y = 0.0f, .size.width = width, .size.height = partialHeight}, partialImageRef);
                    CGImageRelease(partialImageRef);
                    partialImageRef = CGBitmapContextCreateImage(bmContext);
                    CGContextRelease(bmContext);
                }
                else {
                    CGImageRelease(partialImageRef);
                    partialImageRef = nil;
                }
            }
#endif

            if (partialImageRef) {
#if SD_UIKIT || SD_WATCH
                UIImage *image = [UIImage imageWithCGImage:partialImageRef scale:1 orientation:orientation];
#elif SD_MAC
                UIImage *image = [[UIImage alloc] initWithCGImage:partialImageRef size:NSZeroSize];
#endif
                NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:self.request.URL];
                UIImage *scaledImage = [self scaledImageForKey:key image:image];
                if (self.shouldDecompressImages) {
                    image = [UIImage decodedImageWithImage:scaledImage];
                }
                else {
                    image = scaledImage;
                }
                CGImageRelease(partialImageRef);
                
                [self callCompletionBlocksWithImage:image imageData:nil error:nil finished:NO];
            }
        }

        CFRelease(imageSource);
    }

    for (SDWebImageDownloaderProgressBlock progressBlock in [self callbacksForKey:kProgressCallbackKey]) {
        progressBlock(self.imageData.length, self.expectedSize, self.request.URL);
    }
}

　　当收到数据的时候执行的代理方法。这个代理方法会循环调用多次，直到整张图片被下载完毕。

　　当 self.options 是 SDWebImageDownloaderProgressiveDownload （按下载的进度显示图片，可以看到图片从上到下一行一行的加载，直到整个图片加载完毕）的时候并且 self.expectedSize 大于 0 的时候会执行一大段操作。

　　原本的按照正常的思路，可能是接收到数据的时候，只要把数据拼接起来，根据设置的下载选项，调用下载进度的回调就行了。

　　当下载图片要按进度的方式显示下载的图片的时候，即使图片没有下载完，也能根据已经下载的部分图片数据来显示一张数据不完整的图片。

　　当第一次回调接收到数据的代理方法的时候：

　　self.imageData 已经在上面回调收到响应的代理方法里面进行了初始化（使用 - (nullable instancetype)initWithCapacity:(NSUInteger)capacity 和 预期的图片的大小来做初始化）,在接收数据的回调方法里面，每次数据回来都会添加进 self.imageData。

　　totalSize 纪录每次 self.imageData 的长度。

　　每次使用 self.imageData 创建 imageSource (CGImageSourceRef)。

　　imageSource 使用完毕要释放：

CFRelease(imageSource);

typedef struct IIO_BRIDGED_TYPE(id) CGImageSource * CGImageSourceRef;

　　如果当前 width 加 height 等于 0 的时候，多半是第一次回调接收数据的代理方法。

　　使用 imageSource  获取 properties (CFDictionaryRef)，

typedef const struct CF_BRIDGED_TYPE(NSDictionary) __CFDictionary * CFDictionaryRef;

　　properties 用来分别获取图片的 width、height、orientationValue 并赋值给各个对应的属性。

                NSInteger orientationValue = -1;
                CFTypeRef val = CFDictionaryGetValue(properties, kCGImagePropertyPixelHeight);
                if (val) CFNumberGetValue(val, kCFNumberLongType, &height);
                val = CFDictionaryGetValue(properties, kCGImagePropertyPixelWidth);
                if (val) CFNumberGetValue(val, kCFNumberLongType, &width);
                val = CFDictionaryGetValue(properties, kCGImagePropertyOrientation);
                if (val) CFNumberGetValue(val, kCFNumberNSIntegerType, &orientationValue);

　　使用完毕要释放 properties。

CFRelease(properties);

　　

　　(其实完全看不懂上面的 ImageIO 框架的用法。)

 

　　如果当前是 iOS 平台或者 TV 平台开发:

　　根据 orientationValue 获取图片的 orientation 。

#if SD_UIKIT || SD_WATCH
+ (UIImageOrientation)orientationFromPropertyValue:(NSInteger)value {
    switch (value) {
        case 1:
            return UIImageOrientationUp;
        case 3:
            return UIImageOrientationDown;
        case 8:
            return UIImageOrientationLeft;
        case 6:
            return UIImageOrientationRight;
        case 2:
            return UIImageOrientationUpMirrored;
        case 4:
            return UIImageOrientationDownMirrored;
        case 5:
            return UIImageOrientationLeftMirrored;
        case 7:
            return UIImageOrientationRightMirrored;
        default:
            return UIImageOrientationUp;
    }
}
#endif

 　　综上所述，当 width + height == 0  的 if 语句里面，只是为了获取图像的宽高方向，三个属性。

　　下面 (width + height > 0 && totalSize < self.expectedSize) 的 if 语句里面才是主要对图片数据进行的处理，当接收数据的回调不是第一次调用的时候，width 和 height 大于 0 的时候:

　　使用 imageSource 创建当前下载的数据组成的部分图片 partialImageRef (CGImageRef)。

typedef struct CGImage *CGImageRef;

　　如果当前是 iOS 平台或者 TV 平台或者 WATCH 平台：

　　使用 partialImageRef 获取高度赋值给 partialHeight (size_t)。

　　CGColorSpaceCreateDeviceRGB() 初始化一个 CGColorSpaceRef 实例 colorSpace。

　　使用完毕需要释放:

CGColorSpaceRelease(colorSpace);

　　使用上面的 width、height、colorSpace 以及 kCGBitmapByteOrderDefault、kCGImageAlphaPremultipliedFirst，做参数创建一个 CGContextRef  实例 bmContext。

　　 bmContext 使用完毕需要释放:

CGContextRelease(bmContext);

　　如果 bmContext 存在，使用 CGContextDrawImage，把上面获取到的 width 和 partialHeight、partialImageRef 做参数，写入到 bmContext 里面。然后释放 partialImageRef ：

CGImageRelease(partialImageRef);

　　使用 bmContext 和 CGBitmapContextCreateImage 创建一个新的 CGImageRef，并赋值给 partialImageRef。释放 bmContext。

　　如果 bmContext 不存在，则直接释放 partialImageRef 并把它置为 nil。

 　　

　　然后再往下:

　　如果 partialImageRef 存在，则使用 partialImageRef 做参数根据不同的开发平台创建 UIImage。

　　最主要区别是 iOS 平台、TV 平台、WATCH 平台，使用：

+ (UIImage *)imageWithCGImage:(CGImageRef)cgImage scale:(CGFloat)scale orientation:(UIImageOrientation)orientation NS_AVAILABLE_IOS(4_0);

　　创建 UIImage，需要一个表示图片方向的参数 orientation。MAC 平台则没有。

　　使用 self.request.URL 获取图片的 key，调整图片的大小。

　　根据  self.shouldDecompressImage 属性判断是否需要解压图片。

　　然后释放 partialImageRef。

CGImageRelease(partialImageRef);

　　然后调用 finished 为 NO 的下载完成的 block：

- (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);
        }
    });
}

　　

　　如果在代理方法最开始的时候，self.options  不是 SDWebImageDownloaderProgressiveDownload 或者 self.expectedSize 不大于 0 的时候:

　　遍历执行下载进度的 block。

 

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

    responseFromCached = NO; // If this method is called, it means the response wasn't read from cache
    NSCachedURLResponse *cachedResponse = proposedResponse;

    if (self.request.cachePolicy == NSURLRequestReloadIgnoringLocalCacheData) {
        // Prevents caching of responses
        cachedResponse = nil;
    }
    if (completionHandler) {
        completionHandler(cachedResponse);
    }
}

　　该方法用于响应的缓存设置，如果把回调的参数设置为 nil，那么就不会缓存响应，真正缓存的数据就是回调中的参数。

　　

　　NSURLSessionTaskDelegate

- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
    @synchronized(self) {
        self.dataTask = nil;
        dispatch_async(dispatch_get_main_queue(), ^{
            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:self];
            if (!error) {
                [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadFinishNotification object:self];
            }
        });
    }
    
    if (error) {
        [self callCompletionBlocksWithError:error];
    } else {
        if ([self callbacksForKey:kCompletedCallbackKey].count > 0) {
            /**
             *  See #1608 and #1623 - apparently, there is a race condition on `NSURLCache` that causes a crash
             *  Limited the calls to `cachedResponseForRequest:` only for cases where we should ignore the cached response
             *    and images for which responseFromCached is YES (only the ones that cannot be cached).
             *  Note: responseFromCached is set to NO inside `willCacheResponse:`. This method doesn't get called for large images or images behind authentication
             */
            if (self.options & SDWebImageDownloaderIgnoreCachedResponse && responseFromCached && [[NSURLCache sharedURLCache] cachedResponseForRequest:self.request]) {
                // hack
                [self callCompletionBlocksWithImage:nil imageData:nil error:nil finished:YES];
            } else if (self.imageData) {
                UIImage *image = [UIImage sd_imageWithData:self.imageData];
                NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:self.request.URL];
                image = [self scaledImageForKey:key image:image];
                
                // Do not force decoding animated GIFs
                if (!image.images) {
                    if (self.shouldDecompressImages) {
                        if (self.options & SDWebImageDownloaderScaleDownLargeImages) {
#if SD_UIKIT || SD_WATCH
                            image = [UIImage decodedAndScaledDownImageWithImage:image];
                            [self.imageData setData:UIImagePNGRepresentation(image)];
#endif
                        } else {
                            image = [UIImage decodedImageWithImage:image];
                        }
                    }
                }
                if (CGSizeEqualToSize(image.size, CGSizeZero)) {
                    [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Downloaded image has 0 pixels"}]];
                } else {
                    [self callCompletionBlocksWithImage:image imageData:self.imageData error:nil finished:YES];
                }
            } else {
                [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Image data is nil"}]];
            }
        }
    }
    [self done];
}

　　当图片下载完成之后的代理方法。

　　把  self.dataTask 置为 nil。

　　异步调取主线程，先发送一个 SDWebImageDownloadStopNotification 的通知，如果没有 error 则再发送一个 SDWebImageDownloadFinishNotification 的通知。

　　如果有 error，则回调 image 是 nil，imageData 是 nil，error  是 error，finished 是YES 的 完成的 block。

- (void)callCompletionBlocksWithError:(nullable NSError *)error {
    [self callCompletionBlocksWithImage:nil imageData:nil error:error finished:YES];
}

　　如果没有 error，则执行图片正常下载完毕的方法：

　　如果 self.callbackBlocks 里面 completed 的 count 大于 0：

　　如果 self.options 是 SDWebImageDownloaderIgnoreCachedResponse 并且 responseFromCached 为真、并且 [[NSURLCache sharedURLCache] cachedResponseForRequest:self.request] 存在，则直接执行 image 是 nil、imageData 是 nil、error 是 nil、Finished 为 YES 的完成的 block。

　　其它的，如果 self.imageData 存在：

　　使用 self.imageData 转化为图片 image。

　　使用 self.request.URL 获取图片的 key。

　　对 image 根据 key 做 缩放处理。

　　不要强迫解码动效图片。

　　如果不是动图，如果 self.shouldDecompressImage 是 YES，如果 self.options 是 SDWebImageDownloaderScaleDownLargeImages，且当前是 iOS 平台或者 TV 平台或者 WATCH 平台，对 image 进行压缩，并刷新  self.imageData 的数据。

　　否则只对 image 进行解压。

　　如果 image.size 是 CGSizeZero，则携带错误信息回调完成的 block：

[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Downloaded image has 0 pixels"}]

　　否则正常携带图片信息回调完成的 block。

　　

　　如果上面的 self.imageData 不存在：

　　携带错误信息回调完成的 block：

[NSError errorWithDomain:SDWebImageErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey : @"Image data is nil"}]

 　　最后调用 done 方法。

 

- (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);
    }
}

　　这个方法跟HTTPS有点关系，要想说明白这个方法究竟干了什么事？ 需要对验证有点了解才行。

　　当我们发出了一个请求，这个请求到达服务器后，假定服务器设置了需要验证。那么这个方法就会被调用。服务器会返回去一个NSURLAuthenticationChallenge。通过NSURLAuthenticationChallenge的protectionSpace,获取授权method。如果这个metho是服务器信任的， 那么我们就可以直接使用服务器返回的证书，当然，我们也可以使用自己的证书，其他情况都会被认为验证失败，当前请求将会被取消。当有了证书后，客户端就可以使用证书中的公钥对数据进行加密了。

 

参考链接:http://www.jianshu.com/p/662c09582d30

http://blog.csdn.net/book_1992/article/details/52133818

http://blog.csdn.net/lmyuanhang/article/details/48442073

http://blog.sina.com.cn/s/blog_7b9d64af0101cjci.html

http://www.cnblogs.com/linzhengbo/p/6126755.html

http://www.jianshu.com/p/4dcd6e4bdbf0 

END