SDWebImage 5.0.1版本 深度解析

最新推荐文章于 2024-04-17 09:55:54 发布
最新推荐文章于 2024-04-17 09:55:54 发布
阅读量1.8k 收藏 1
点赞数
文章标签： ui 数据结构与算法
原文链接：https://juejin.im/post/5cbe79a8f265da03826118c8
版权

地址 github.com/SDWebImage/…

首先我觉得应该对该框架有一个宏观层面的了解，根据这个思路，层层去分析。

加载流程

这是官方的时序图。

我们看到大致上还有以下的流程。

1.调用- (void)sd_setImageWithURL:(nullable NSURL *)url（类似的方法有很多种，在UIImageView+WebCache文件中）。

2.进入?口sd_internalSetImageWithURL（在UIView+WebCach文件中e）。

3.下载图片。

4.下载之前，先去查找图片（通过url，先查缓存后查磁盘，也可以设置查不查缓存）。

5.如果有的话，返回结果。

6.真正的去下载图片

7.返回下载的结果。

8.将下载的图片存在磁盘和缓存中（可以设置是否存到缓存）。

麻辣鸡上次写的东西 存不上 都没了、、。从写一遍吧

一些要记住的枚举 和 常量##

枚举采用位运算的方式，可以选择多个用 | 隔开。关于位运算，之后再写。 注释写的很清楚了，可以自己看。

typedef NS_OPTIONS(NSUInteger, SDWebImageOptions) {
    失败重试，有一个加载失败的url数组。每次都在数组中查询一下，
    如果设置失败重试了，就开始下载。如果设置了失败不重试，就不下载。
    SDWebImageRetryFailed = 1 << 0,

    低优先级
    SDWebImageLowPriority = 1 << 1,

    只在保存到内存中
    SDWebImageCacheMemoryOnly = 1 << 2,

    渐进下载，类似于浏览器的的方式。
    SDWebImageProgressiveDownload = 1 << 3,

    刷新内存，下完完成之后进行比对，如果图片变了 就刷新缓存中的图片。
    SDWebImageRefreshCached = 1 << 4,

    后台下载，当设置了后台操作的时候，就会自动进行，超期了自动停止
    SDWebImageContinueInBackground = 1 << 5,

    设置cookies 不知道干啥用的。。
    SDWebImageHandleCookies = 1 << 6,

    允许无效的证书，如果url是https的，但是没有证书的话，用这个选项。
    SDWebImageAllowInvalidSSLCertificates = 1 << 7,

    高优先级
    SDWebImageHighPriority = 1 << 8,
    
    延迟设置占位图
    SDWebImageDelayPlaceholder = 1 << 9,

    转换动画图片，当设置了这个，所有的动画图片都会被转换。
    SDWebImageTransformAnimatedImage = 1 << 10,
    
    取消下载完成之后 自动设置图片。
    SDWebImageAvoidAutoSetImage = 1 << 11,
    
    取消自动缩放，
    SDWebImageScaleDownLargeImages = 1 << 12,
    
    当图片在内存中的时候 也去同步查找磁盘。
    SDWebImageQueryDataWhenInMemory = 1 << 13,
    
    通常查找磁盘是异步的，可以设置成同步的。
    SDWebImageQueryDiskSync = 1 << 14,
    
    只从内存中查找图片
    SDWebImageFromCacheOnly = 1 << 15,
   
    转换图片，比如 webp转成png。
    SDWebImageForceTransition = 1 << 16
};

typedef NS_OPTIONS(NSUInteger, SDWebImageDownloaderOptions) {
    低优先级
    SDWebImageDownloaderLowPriority = 1 << 0,
    
    渐进下载
    SDWebImageDownloaderProgressiveDownload = 1 << 1,

    使用NSURLCache 不知道干啥的，。
    SDWebImageDownloaderUseNSURLCache = 1 << 2,

    无视NSURLCache的响应数据
    SDWebImageDownloaderIgnoreCachedResponse = 1 << 3,
    
    后台下载
    SDWebImageDownloaderContinueInBackground = 1 << 4,

    设置cookies
    SDWebImageDownloaderHandleCookies = 1 << 5,

    允许无效的证书
    SDWebImageDownloaderAllowInvalidSSLCertificates = 1 << 6,

    高优先级
    SDWebImageDownloaderHighPriority = 1 << 7,
    
    自动缩放
    SDWebImageDownloaderScaleDownLargeImages = 1 << 8,
};

typedef NS_ENUM(NSInteger, SDWebImageDownloaderExecutionOrder) {
    
    队列数据结构 先进先出
    (first-in-first-out).
    SDWebImageDownloaderFIFOExecutionOrder,

    栈结构 后进先出
    (last-in-first-out).
    SDWebImageDownloaderLIFOExecutionOrder
};

typedef NS_ENUM(NSInteger, SDImageCacheType) {
    不缓存
    SDImageCacheTypeNone,
    磁盘缓存
    SDImageCacheTypeDisk,
    内存缓存
    SDImageCacheTypeMemory
};

typedef NS_OPTIONS(NSUInteger, SDImageCacheOptions) {
    在内存中的时候，也去同步查找存盘
    SDImageCacheQueryDataWhenInMemory = 1 << 0,
    同步去查查找磁盘
    SDImageCacheQueryDiskSync = 1 << 1,
    取消自动缩放
    SDImageCacheScaleDownLargeImages = 1 << 2
};

SD_UIKIT
// iOS and tvOS are very similar, UIKit exists on both platforms
#if TARGET_OS_IOS || TARGET_OS_TV
    #define SD_UIKIT 1
#else
    #define SD_UIKIT 0
#endif

信号量当做锁来用
#define LOCK(lock) dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
#define UNLOCK(lock) dispatch_semaphore_signal(lock);
复制代码

几个关键的类 简要说明##

SDImageCache 缓存类

内存缓存采用的是NSCache 和 NSMapTable结合的方式。因为NSCache有的时候会自动释放，不受控制。我猜NSMapTable是拉链法的散列表。

YYCache也是继承NSCache，但是是用自己实现的双向链表来完成自定义的内存缓存。

SDWebImageDownloader 下载类

SDWebImageManager 核心类

这个类 是下载和查找的入口。是sd的灵魂。

UIView+WebCache UI层面调用的入口 不管是imageView button，最后都会调用到这里。

根据流程一行一行代码的看

- (void)sd_setImageWithURL:(nullable NSURL *)url
          placeholderImage:(nullable UIImage *)placeholder
                   options:(SDWebImageOptions)options
                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                 completed:(nullable SDExternalCompletionBlock)completedBlock;
    参数没有什么好说的了。
    
最终会调用以下方法

代码段1
- (void)sd_internalSetImageWithURL:(nullable NSURL *)url
                  placeholderImage:(nullable UIImage *)placeholder
                           options:(SDWebImageOptions)options
                      operationKey:(nullable NSString *)operationKey
                     setImageBlock:(nullable SDSetImageBlock)setImageBlock
                          progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                         completed:(nullable SDExternalCompletionBlock)completedBlock
                           context:(nullable NSDictionary<NSString *, id> *)context {
    //设置validOperationKey 
    NSString *validOperationKey = operationKey ?: NSStringFromClass([self class]);
    //通过validOperationKey 看有没有在下载的队列中，如果在的话，就取消下载并且从队列中移除。这里用了同步锁来保存线程安安全。
    [self sd_cancelImageLoadOperationWithKey:validOperationKey];
    绑定新的url
    objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    //& 位运算 不知道的同学查找 按位与 就可以了
    //如果没有设置延迟设置占位图的话 就立刻设置占位图。
    if (!(options & SDWebImageDelayPlaceholder)) {
        dispatch_main_async_safe(^{
        //如果设置了回调 就通过回调把占位图传回去，若果没设置block
        判断是不是UIImageView，是的话就直接设置。
            [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock];
        });
    }
    
    if (url) {
#if SD_UIKIT
        //如果设置了显示系统菊花，就显示出来。
        if ([self sd_showActivityIndicatorView]) {
            [self sd_addActivityIndicator];
        }
#endif
        
        // 重置进度
        self.sd_imageProgress.totalUnitCount = 0;
        self.sd_imageProgress.completedUnitCount = 0;
        
        SDWebImageManager *manager;
        //如果设置了单例mananger之外的mananger就取出来，赋值。
        //sd是允许使用其他方式初始化的manager的。
        if ([context valueForKey:SDWebImageExternalCustomManagerKey]) {
            manager = (SDWebImageManager *)[context valueForKey:SDWebImageExternalCustomManagerKey];
        } else {
        //如果没有设置额外的manager ，就获取单例。
            manager = [SDWebImageManager sharedManager];
        }
        
        __weak __typeof(self)wself = self;
        //进度的block回调
        SDWebImageDownloaderProgressBlock combinedProgressBlock = ^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
            wself.sd_imageProgress.totalUnitCount = expectedSize;
            wself.sd_imageProgress.completedUnitCount = receivedSize;
            //如果设置了进度block 就回调回去
            if (progressBlock) {
                progressBlock(receivedSize, expectedSize, targetURL);
            }
        };
        //这个方法的代码在下一段中贴出来讲解。
        //可以理解为已经得到了图片。
        id <SDWebImageOperation> operation = [manager loadImageWithURL:url options:options progress:combinedProgressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
            __strong __typeof (wself) sself = wself;
            if (!sself) { return; }
#if SD_UIKIT
            //移除菊花
            [sself sd_removeActivityIndicator];
#endif
            // if the progress not been updated, mark it to complete state
            //如果完成了。且没有错误且总数=0.且完成=0，就把进度和数量设置为位置的。真的很严谨。
            if (finished && !error && sself.sd_imageProgress.totalUnitCount == 0 && sself.sd_imageProgress.completedUnitCount == 0) {
                sself.sd_imageProgress.totalUnitCount = SDWebImageProgressUnitCountUnknown;
                sself.sd_imageProgress.completedUnitCount = SDWebImageProgressUnitCountUnknown;
            }
            //看设置了取消自动赋值吗
            BOOL shouldCallCompletedBlock = finished || (options & SDWebImageAvoidAutoSetImage);
            //看 需不需要自动赋值
            //第一个判断条件。有图片且取消了自动赋值
            //第二个判断条件。没图片且没有设置延迟设置占位图
            BOOL shouldNotSetImage = ((image && (options & SDWebImageAvoidAutoSetImage)) ||
                                      (!image && !(options & SDWebImageDelayPlaceholder)));
            SDWebImageNoParamsBlock callCompletedBlockClojure = ^{
                if (!sself) { return; }
                //要自动设置图片
                if (!shouldNotSetImage) {
                //把这个view设置成NeedsLayout，在下一个对应mode的Runloop循环的时候，会去重新计算。
                    [sself sd_setNeedsLayout];
                }
                //如果需要回调。
                if (completedBlock && shouldCallCompletedBlock) {
                    completedBlock(image, error, cacheType, url);
                }
            };
            
            // case 1a: we got an image, but the SDWebImageAvoidAutoSetImage flag is set
            // OR
            // case 1b: we got no image and the SDWebImageDelayPlaceholder is not set
            if (shouldNotSetImage) {
            //如果不用去设置图片 调用block 结束了
                dispatch_main_async_safe(callCompletedBlockClojure);
                return;
            }
            
            UIImage *targetImage = nil;
            NSData *targetData = nil;
            if (image) {
                // case 2a: we got an image and the SDWebImageAvoidAutoSetImage is not set
                //解释的很清楚了。。
                targetImage = image;
                targetData = data;
            } else if (options & SDWebImageDelayPlaceholder) {
                // case 2b: we got no image and the
                SDWebImageDelayPlaceholder flag is set
                //解释的很清楚了。。
                targetImage = placeholder;
                targetData = nil;
            }
            
#if SD_UIKIT || SD_MAC
            // check whether we should use the image transition
            SDWebImageTransition *transition = nil;
            //如果设置了图片转换或者不缓存，不缓存这个条件我没懂
            if (finished && (options & SDWebImageForceTransition || cacheType == SDImageCacheTypeNone)) {
                transition = sself.sd_imageTransition;
            }
#endif
            dispatch_main_async_safe(^{
#if SD_UIKIT || SD_MAC
                //设置图片，设置了转换的话 做相应的处理。
                [sself sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:transition cacheType:cacheType imageURL:imageURL];
#else
                [sself sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock];
#endif
                //完成的回调
                callCompletedBlockClojure();
            });
        }];
        //处理下载队列
        [self sd_setImageLoadOperation:operation forKey:validOperationKey];
    } else {
        dispatch_main_async_safe(^{
#if SD_UIKIT
            [self sd_removeActivityIndicator];
#endif
            if (completedBlock) {
                NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:-1 userInfo:@{NSLocalizedDescriptionKey : @"Trying to load a nil url"}];
                completedBlock(nil, error, SDImageCacheTypeNone, url);
            }
        });
    }
}
复制代码
代码段2
这段代码完成了，查找和下载的操作
- (id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url
                                     options:(SDWebImageOptions)options
                                    progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                   completed:(nullable SDInternalCompletionBlock)completedBlock {
    // Invoking this method without a completedBlock is pointless
    //断言 参数不符合的话 就崩溃在这里。
    NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -[SDWebImagePrefetcher prefetchURLs] instead");

    //使用者总是有这个错误。。。没办法。。作者屈服了 加了判断。
    if ([url isKindOfClass:NSString.class]) {
        url = [NSURL URLWithString:(NSString *)url];
    }

    // 保护程序 防止崩溃 null 就炸了。
    if (![url isKindOfClass:NSURL.class]) {
        url = nil;
    }

    SDWebImageCombinedOperation *operation = [SDWebImageCombinedOperation new];
    operation.manager = self;
    
    //看是不是这个url在不在下载失败的数组里
    BOOL isFailedUrl = NO;
    if (url) {
    //用信号量 保证线程安全。
        LOCK(self.failedURLsLock);
        isFailedUrl = [self.failedURLs containsObject:url];
        UNLOCK(self.failedURLsLock);
    }
    //url 没有值，失败不重试，在下载失败的数组中
    if (url.absoluteString.length == 0 || (!(options & SDWebImageRetryFailed) && isFailedUrl)) {
    //完成回调 ， 设置error ， 返回结束。
        [self callCompletionBlockForOperation:operation completion:completedBlock error:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil] url:url];
        return operation;
    }
    //先锁，然后再操作队列中加入本次操作。
    LOCK(self.runningOperationsLock);
    [self.runningOperations addObject:operation];
    UNLOCK(self.runningOperationsLock);
    //通过url 返回key，这个转化规则，可以自定义规则。
    NSString *key = [self cacheKeyForURL:url];
    
    SDImageCacheOptions cacheOptions = 0;
    //根据SDWebImageOptions 设置 SDImageCacheOptions。
    // cacheOptions|= SDImageCacheQueryDataWhenInMemory 做位或计算，将结果赋值给cacheOptions
    // 等价于 cacheOptions = cacheOptions | SDImageCacheQueryDataWhenInMemory；
    // 按位或 每一位都进行比较 相同的位都是1 ，结果的那一位就是1.排除其他的影响。
    if (options & SDWebImageQueryDataWhenInMemory) cacheOptions |= SDImageCacheQueryDataWhenInMemory;
    if (options & SDWebImageQueryDiskSync) cacheOptions |= SDImageCacheQueryDiskSync;
    if (options & SDWebImageScaleDownLargeImages) cacheOptions |= SDImageCacheScaleDownLargeImages;
    
    __weak SDWebImageCombinedOperation *weakOperation = operation;
    //去查找缓存 代码段3详细说明。这里可以先看做已经查到了。
    operation.cacheOperation = [self.imageCache queryCacheOperationForKey:key options:cacheOptions done:^(UIImage *cachedImage, NSData *cachedData, SDImageCacheType cacheType) {
        __strong __typeof(weakOperation) strongOperation = weakOperation;
        if (!strongOperation || strongOperation.isCancelled) {
        //如果操作被取消了 就安全的从操作队列中移除。
            [self safelyRemoveOperationFromRunning:strongOperation];
            return;
        }
        
        // 看需不需要从网络下载图片。
        //条件1 不是只从内存中查找。
        //条件2 缓存中没有图片，或者刷新内存中的图片
        //条件3 设置了下载的代理
        BOOL shouldDownload = (!(options & SDWebImageFromCacheOnly))
            && (!cachedImage || options & SDWebImageRefreshCached)
            && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegate imageManager:self shouldDownloadImageForURL:url]);
        //需要下载
        if (shouldDownload) {
            //如果缓存中有图片且设置了刷新缓存
            if (cachedImage && options & SDWebImageRefreshCached) {
                // If image was found in the cache but SDWebImageRefreshCached is provided, notify about the cached image
                // AND try to re-download it in order to let a chance to NSURLCache to refresh it from server.
                //很详细 不翻译了
                [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];
            }

            // download if no image or requested to refresh anyway, and download allowed by delegate
            SDWebImageDownloaderOptions downloaderOptions = 0;
             //根据SDWebImageOptions 设置 SDWebImageDownloaderOptions。
             // cacheOptions|= SDImageCacheQueryDataWhenInMemory   做位或计算，将结果赋值给cacheOptions
             // 等价于 cacheOptions = cacheOptions | SDImageCacheQueryDataWhenInMemory；
             // 按位或 每一位都进行比较 相同的位都是1 ，结果的那一位就是1.排除其他的影响。
            if (options & SDWebImageLowPriority) downloaderOptions |= SDWebImageDownloaderLowPriority;
            if (options & SDWebImageProgressiveDownload) downloaderOptions |= SDWebImageDownloaderProgressiveDownload;
            if (options & SDWebImageRefreshCached) downloaderOptions |= SDWebImageDownloaderUseNSURLCache;
            if (options & SDWebImageContinueInBackground) downloaderOptions |= SDWebImageDownloaderContinueInBackground;
            if (options & SDWebImageHandleCookies) downloaderOptions |= SDWebImageDownloaderHandleCookies;
            if (options & SDWebImageAllowInvalidSSLCertificates) downloaderOptions |= SDWebImageDownloaderAllowInvalidSSLCertificates;
            if (options & SDWebImageHighPriority) downloaderOptions |= SDWebImageDownloaderHighPriority;
            if (options & SDWebImageScaleDownLargeImages) downloaderOptions |= SDWebImageDownloaderScaleDownLargeImages;
            
            if (cachedImage && options & SDWebImageRefreshCached) {
                // force progressive off if image already cached but forced refreshing
                //downloaderOptions = ~(downloaderOptions &  SDWebImageDownloaderProgressiveDownload)取反
                downloaderOptions &= ~SDWebImageDownloaderProgressiveDownload;
                // ignore image read from NSURLCache if image if cached but force refreshing
                downloaderOptions |= SDWebImageDownloaderIgnoreCachedResponse;
            }
            
            // `SDWebImageCombinedOperation` -> `SDWebImageDownloadToken` -> `downloadOperationCancelToken`, which is a `SDCallbacksDictionary` and retain the completed block below, so we need weak-strong again to avoid retain cycle
            __weak typeof(strongOperation) weakSubOperation = strongOperation;
            //真正开始下载
            strongOperation.downloadToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *downloadedData, NSError *error, BOOL finished) {
                __strong typeof(weakSubOperation) strongSubOperation = weakSubOperation;
                //下载操作取消了 什么也不做 github的ieesu 699 有详细说明
                if (!strongSubOperation || strongSubOperation.isCancelled) {
                    // Do nothing if the operation was cancelled
                    // See #699 for more details
                    // if we would call the completedBlock, there could be a race condition between this block and another completedBlock for the same object, so if this one is called second, we will overwrite the new data
                } else if (error) {
                     //错误了 返回
                    [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock error:error url:url];
                    BOOL shouldBlockFailedURL;
                    // Check whether we should block failed url
                    //如果需要返回错误的url
                    if ([self.delegate respondsToSelector:@selector(imageManager:shouldBlockFailedURL:withError:)]) {
                        shouldBlockFailedURL = [self.delegate imageManager:self shouldBlockFailedURL:url withError:error];
                    } else {
                        //看是否有任何错误
                        shouldBlockFailedURL = (   error.code != NSURLErrorNotConnectedToInternet
                                                && error.code != NSURLErrorCancelled
                                                && error.code != NSURLErrorTimedOut
                                                && error.code != NSURLErrorInternationalRoamingOff
                                                && error.code != NSURLErrorDataNotAllowed
                                                && error.code != NSURLErrorCannotFindHost
                                                && error.code != NSURLErrorCannotConnectToHost
                                                && error.code != NSURLErrorNetworkConnectionLost);
                    }
                    
                    if (shouldBlockFailedURL) {
                        LOCK(self.failedURLsLock);
                        //添加到失败url的数组
                        [self.failedURLs addObject:url];
                        UNLOCK(self.failedURLsLock);
                    }
                }
                //没有错误
                else {
                    //设置了失败重试的话 ，把url 从失败的数组中移除。
                    if ((options & SDWebImageRetryFailed)) {
                        LOCK(self.failedURLsLock);
                        [self.failedURLs removeObject:url];
                        UNLOCK(self.failedURLsLock);
                    }
                    //是否缓存到磁盘中 只有设置了SDWebImageCacheMemoryOnly 才不存到磁盘。
                    BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly);
                    
                    // We are done the scale process in SDWebImageDownloader with the shared manager, this is used for custom manager and avoid extra scale.
                    //下载过程中，已经进行了缩放，如果有自定义的manager ，避免重复的缩放。
                    if (self != [SDWebImageManager sharedManager] && self.cacheKeyFilter && downloadedImage) {
                        downloadedImage = [self scaledImageForKey:key image:downloadedImage];
                    }
                    //NSURLCache 缓存命中
                    if (options & SDWebImageRefreshCached && cachedImage && !downloadedImage) {
                        // Image refresh hit the NSURLCache cache, do not call the completion block
                        //如果图片下载完成 且 下载的图片只有一个 或者 设置了SDWebImageTransformAnimatedImage
                    } else if (downloadedImage && (!downloadedImage.images || (options & SDWebImageTransformAnimatedImage)) && [self.delegate respondsToSelector:@selector(imageManager:transformDownloadedImage:withURL:)]) {
                       
                       //出来图片转换之后的情况
                        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                            UIImage *transformedImage = [self.delegate imageManager:self transformDownloadedImage:downloadedImage withURL:url];

                            if (transformedImage && finished) {
                                //检查图片有没有被编辑过
                                BOOL imageWasTransformed = ![transformedImage isEqual:downloadedImage];
                                NSData *cacheData;
                                // pass nil if the image was transformed, so we can recalculate the data from the image
                                // 如果设置了全局的解析转换
                                if (self.cacheSerializer) {
                                    cacheData = self.cacheSerializer(transformedImage, (imageWasTransformed ? nil : downloadedData), url);
                                } else {
                                    cacheData = (imageWasTransformed ? nil : downloadedData);
                                }
                                //缓存  请看代码段4
                                [self.imageCache storeImage:transformedImage imageData:cacheData forKey:key toDisk:cacheOnDisk completion:nil];
                            }
                            //完成的block回调
                            [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock image:transformedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                        });
                    } else {
                        //下载图片成功 且 完成
                        if (downloadedImage && finished) {
                            if (self.cacheSerializer) {
                                dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                                    NSData *cacheData = self.cacheSerializer(downloadedImage, downloadedData, url);
                                    [self.imageCache storeImage:downloadedImage imageData:cacheData forKey:key toDisk:cacheOnDisk completion:nil];
                                });
                            } else {
                                //保存内存和磁盘
                                [self.imageCache storeImage:downloadedImage imageData:downloadedData forKey:key toDisk:cacheOnDisk completion:nil];
                            }
                        }
                        [self callCompletionBlockForOperation:strongSubOperation completion:completedBlock image:downloadedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                    }
                }

                if (finished) {
                    [self safelyRemoveOperationFromRunning:strongSubOperation];
                }
            }];
            //图片在内存中
        } else if (cachedImage) {
            [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];
            [self safelyRemoveOperationFromRunning:strongOperation];
        } else {
            // Image not in cache and download disallowed by delegate
            [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:nil data:nil error:nil cacheType:SDImageCacheTypeNone finished:YES url:url];
            [self safelyRemoveOperationFromRunning:strongOperation];
        }
    }];

    return operation;
}


复制代码
代码段3 下载
- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
                                                   options:(SDWebImageDownloaderOptions)options
                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
    __weak SDWebImageDownloader *wself = self;

    return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
        __strong __typeof (wself) sself = wself;
        NSTimeInterval timeoutInterval = sself.downloadTimeout;
        if (timeoutInterval == 0.0) {
            timeoutInterval = 15.0;
        }

        // In order to prevent from potential duplicate caching (NSURLCache + SDImageCache) we disable the cache for image requests if told otherwise
        NSURLRequestCachePolicy cachePolicy = options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData;
        NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url
                                                                    cachePolicy:cachePolicy
                                                                timeoutInterval:timeoutInterval];
        
        request.HTTPShouldHandleCookies = (options & SDWebImageDownloaderHandleCookies);
        request.HTTPShouldUsePipelining = YES;
        if (sself.headersFilter) {
            request.allHTTPHeaderFields = sself.headersFilter(url, [sself allHTTPHeaderFields]);
        }
        else {
            request.allHTTPHeaderFields = [sself allHTTPHeaderFields];
        }
        SDWebImageDownloaderOperation *operation = [[sself.operationClass alloc] initWithRequest:request inSession:sself.session options:options];
        operation.shouldDecompressImages = sself.shouldDecompressImages;
        
        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;
        }
        
        if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
            // Emulate LIFO execution order by systematically adding new operations as last operation's dependency
            [sself.lastAddedOperation addDependency:operation];
            sself.lastAddedOperation = operation;
        }

        return operation;
    }];
}
复制代码
代码段4 缓存

- (void)storeImage:(nullable UIImage *)image
         imageData:(nullable NSData *)imageData
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    if (!image || !key) {
        if (completionBlock) {
            completionBlock();
        }
        return;
    }
    // if memory cache is enabled
    if (self.config.shouldCacheImagesInMemory) {
        //计算大小
        NSUInteger cost = SDCacheCostForImage(image);
        [self.memCache setObject:image forKey:key cost:cost];
    }
    
    if (toDisk) {
        //ioQueue 队列 先进先出 一个一个来 保证顺序
        dispatch_async(self.ioQueue, ^{
            @autoreleasepool {
                NSData *data = imageData;
                if (!data && image) {
                    // If we do not have any data to detect image format, check whether it contains alpha channel to use PNG or JPEG format
                    SDImageFormat format;
                    if (SDCGImageRefContainsAlpha(image.CGImage)) {
                        format = SDImageFormatPNG;
                    } else {
                        format = SDImageFormatJPEG;
                    }
                    data = [[SDWebImageCodersManager sharedInstance] encodedDataWithImage:image format:format];
                }
                [self _storeImageDataToDisk:data forKey:key];
            }
            
            if (completionBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completionBlock();
                });
            }
        });
    } else {
        if (completionBlock) {
            completionBlock();
        }
    }
}

复制代码

转载于:https://juejin.im/post/5cbe79a8f265da03826118c8

weixin_34245082
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iReport5.0.1版本
11-09
5.0.1版本是其发展历程中的一个重要里程碑，提供了许多改进和新特性，旨在帮助开发者更高效地创建、设计和管理各种复杂的报表。 首先，我们要理解iReport的核心功能。它是一个基于图形用户界面的工具，允许开发者...
Allway sync 5.0.1版本（含注册码）
01-10
《Allway Sync 5.0.1：早期版本的同步利器》 在IT领域，数据同步是至关重要的一环，尤其对于个人用户和企业而言，确保数据的安全与一致性是日常操作中的重要任务。Allway Sync是一款备受推崇的数据同步软件，而我们...
【iOS】—— SDWebImage源码（5.9.5版本）
m0_55124878的博客
05-14 765
图片加载的主要流程
SDWebImage5.0.1版本缓存机制
lcx_love_yx的专栏
04-25 610
一 内部流程顺序： 0 站位图：图片下载是耗时操作，下载前可先显示站位图； 1 内存：以url作为key，去内存中查找； 2 磁盘：内存中没有，以url的MD5作为key，去磁盘中查找，找到则缓存在内存中； 3 下载： *是否下载中：磁盘中也没有，如果此图片没有在下载中，则异步下载；如果在下载中，则继续下载； *下载完成后：分别把图片保存在内存和磁盘中； 4 清除缓存： *收到内...
SD-webUI安装使用教程
最新发布
qq_41314882的博客
04-17 1452
AIGC技术的未来发展前景广阔，随着人工智能技术的不断发展，AIGC技术也将不断提高。未来，AIGC技术将在游戏和计算领域得到更广泛的应用，使游戏和计算系统具有更高效、更智能、更灵活的特性。同时，AIGC技术也将与人工智能技术紧密结合，在更多的领域得到广泛应用，对程序员来说影响至关重要。未来，AIGC技术将继续得到提高，同时也将与人工智能技术紧密结合，在更多的领域得到广泛应用。感兴趣的小伙伴，赠送全套AIGC学习资料和安装工具，包含AI绘画、AI人工智能等前沿科技教程，模型插件，具体看下方。
iOS SDWebImage详细介绍
假装你是大灰狼的专栏
01-18 2623
在iOS的图片加载框架中，SDWebImage使用频率非常高。它支持从网络中下载且缓存图片，并设置图片到对应的UIImageView控件或者UIButton控件。在项目中使用SDWebImage来管理图片加载相关操作可以极大地提高开发效率，让我们更加专注于业务逻辑实现。本文讲解的版本为4.4.2版本。 一、SDWebImage 概论 SDWebImage是个支持异步下载与缓存的UIImageView扩展。项目主要提供了一下功能： 1.提供了一个UIImageView的category用来加载网络图片并且对
解决SDWebimage加载过多过大图片导致内存爆表崩溃的问题
学习笔记
02-25 7975
问题： Restore the connection to “xxxx” and run “xx” again, or if “xx” is still running, you can attach to it by selecting Debug &gt; Attach to Process &gt; xx. 原因： collectionView一屏加载显示多个大图，导致内存消耗激增，...
SDWebImage 图片加载失败
liu_wentao的博客
02-27 4524
今天在项目中，使用SDWebImage加载图片，总有图片加载不出来。使用[self.centerIV sd_setImageWithURL:[NSURL URLWithString:self.sourceDataArr[currentImageIndex]] placeholderImage:self.placeHolderImage completed:^(UIImage *image, NSE...
ollvm5.0.1:obfuscator 基于 llvm 5.0.1 版本
04-27
低层虚拟机（LLVM） =============================== 该目录及其子目录包含LLVM的源代码，LLVM是用于构建高度优化的编译器，优化器...cmake -DCMAKE_BUILD_TYPE =发布../ollvm5.0.1 使-j7 用： -mllvm -bcf -mllvm
NCalendar 5.0.1 Suport 版本
11-19
NCalendar 5.0.1 Android Suport 版本,使用时不用迁移项目到Android X，直接本地依赖这个包，也可以直接用NCalendar。如果是Android x 版本，请直接添加依赖 implementation 'com.necer.ncalendar:ncalendar:5.0.1'
74cms 骑士人才系统 v5.0.1 正式版
10-02
总的来说，74cms骑士人才系统v5.0.1正式版是一个功能完备、易于定制的人才招聘解决方案，适用于各类企业。通过其高效的执行、丰富的功能和灵活的设计，企业能够更好地管理和运营自己的招聘流程，吸引并留住优秀的...
SDWebImage 加载网络图片失败，重新运行，就能加载成功。
dfgwang1202的博客
10-13 210
现象： 使用SDWebImage 加载网络图片，偶尔会有一两张图片就是显示不出来。重新运行有时又可以了。 这个问题的原因是： 当SDWebImage 在加载图片的时候 我用的是- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder；这个方法。在加载过程中因为网络或别的原因造成加载失...
swift 解决SDWebImage同时加载大量高分辨率图片导致的内存爆炸问题
RemiliaScarlet的博客
07-30 1135
问题说明 使用SDWebImage同时加载大量的高分辨率图片。如使用UITableView和UICollectionView展示图片列表时，运营人员上传的图片分辨率过高，导致应用内存占用率爆表引起应用崩溃问题。 解决方法 在加载图片的方法中加入options: SDWebImageOptions.scaleDownLargeImages 示例： UIImageView.sd_setImage(with: url, placeholderImage: placeholderImage, options
SDWebImage加载图片url失败后再次请求无法刷新
Odelia的博客
11-29 1678
其实这个很简单就是因为SDWebImage有个黑名单机制,当某一个url加载图片失败后SDWebImage会把这个url加入到黑名单中.处理办法就是当你在加载某一个url的时候带着参数SDWebImageRetryFailed 也就是不走黑名单机制就可以解决了”’ [self.contentImageView sd_setImageWithURL:[NSURL URLWithString:urls
SDWebImage--http图片加载不出来的问题
Holothurian
08-23 4956
1、百度搜索了一些图片----浏览器右键检查元素----资源---图像---选择想要的图片---右键选择拷贝链接地址。 2、搜集了一堆图片后取链接加入项目中、使用SDWebImage加载图片、然而不显示、寻求解决办法。 3、使用如下方法发现error报错Error Domain=NSURLErrorDomain Code=403 “The operation couldn’t be compl...
SDWebImage的坑，无网络时加载图片失败，有网络后依然无法加载显示的问题
chuangjie3159的博客
02-16 463
网上查找得知 当SDWebImage在加载图片的时候我用的是-(void)sd_setImageWithURL:(NSURL*)urlplaceholderImage:(UIImage*)placeholder；这个方法。在加载过程中因为网络或别的原因造成加载失败！SDWeb把当前...
SDWebImage报错——Error Domain=NSURLErrorDomain Code=-1202
chabuduoxs的博客
05-03 1339
错误情况 NSURL* url = [NSURL URLWithString:_loginModel.data[@"face"]]; [cell.topImageView sd_setImageWithURL:url placeholderImage:nil completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageU
最新版SDWebImage的使用
专注移动开发
12-12 800
我之前写过一篇博客，介绍缓存处理的三种方式，其中最难，最麻烦，最占内存资源的还是图片缓存，最近做的项目有大量的图片处理，还是采用了SDWebImage来处理，但是发现之前封装好的代码报错了。研究发现，是我用了新版的SDWebImage，好多方法都变了。 现在把代码贴出来，供大家参考。尤其是新手，看完这篇博客，图片缓存so easy。最后有demo供大家下载，先学习。 第一步，下载SDW
SDWebImage-解码、压缩图像
rv0p111
03-10 3179
一、简单介绍研究了下SDWebImage的源码，借鉴了别人的一些资料，感觉逐渐的明白的一些原理，现在就来记录下。在我们使用 UIImage 的时候，创建的图片通常不会直接加载到内存，而是在渲染的时候默认在主线程上再进行解码并加载到内存。这就会导致 UIImage 在渲染的时候效率上不是那么高效。为了提高效率所以在SDWebImage中就采取在子线程中进行解码图片。这里再介绍下为什么创建图像的时候是...
ffmpeg 5.0.1版本用C++写一个在vs2019编译通过的rtsp播放器
06-22
首先，您需要下载FFmpeg的最新版本，并将其添加到您的VS2019项目中。在项目属性中添加以下包含目录和库目录： 包含目录：`目录>/include` 库目录：`目录>/lib` 然后，您需要在项目中添加以下库文件： ``` avcodec...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值