SDWebImage源代码解析（一）Cache

2016-09-18 本文已影响306人 game3108

前言

CSDN地址：http://blog.csdn.net/game3108/article/details/52575740
本文的中文注释代码demo更新在我的github上。

SDWebImage是一个十分有名的Objective-C第三方开源框架，作用是：

Asynchronous image downloader with cache support as a UIImageView category

一个异步的图片下载与缓存的UIImageViewCategory。

本文也将对SDWebImage的源代码进行一次简单的解析，当作学习和记录。
SDWebImage源代码较长，本文会分为一个一个部分进行解析。本次解析的部分就是SDImageCache。

SDImageCache使用

SDWebImage的使用十分简单，比较常用的一个接口:

[cell.imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"]
                      placeholderImage:[UIImage imageNamed:@"placeholder.png"]];

只需要一个url和一个placeholderimage，就可以下载图片和设置占位图。

整体结构

SDWebImage整体项目结构图：

SDWebImage

主要分为以下几块：
1.头文件、宏定义、cancel接口
2.Downloader：下载图片
3.Cache:图片缓存
4.Utils:
SDWebImageManager:管理类
SDWebImageDecoder:图片解压缩类
SDWebImagePrefetcher:图片预加载类
5.Categories:相关类使用接口

Cache

SDImageCache是用来缓存图片到内存以及硬盘，它主要包含以下几类方法：

创建Cache空间和路径
存储图片
读取图片
删除图片
删除缓存
清理缓存
获取硬盘缓存大小
判断key是否存在在硬盘

创建Cache空间和路径

SDImageCache的初始化方法就是初始化一些基本的值和注册相关的notification。
相关方法如下：

//单例
+ (SDImageCache *)sharedImageCache;
//初始化一个namespace空间
- (id)initWithNamespace:(NSString *)ns;
//初始化一个namespace空间和存储的路径
- (id)initWithNamespace:(NSString *)ns diskCacheDirectory:(NSString *)directory;
//存储路径
-(NSString *)makeDiskCachePath:(NSString*)fullNamespace;
//添加只读cache的path
- (void)addReadOnlyCachePath:(NSString *)path;

实现如下：

//标准单例创建方法
+ (SDImageCache *)sharedImageCache {
    static dispatch_once_t once;
    static id instance;
    dispatch_once(&once, ^{
        instance = [self new];
    });
    return instance;
}

//添加只读的cachePath
- (void)addReadOnlyCachePath:(NSString *)path {
    //只读路径，只在查找图片时候使用
    if (!self.customPaths) {
        self.customPaths = [NSMutableArray new];
    }

    if (![self.customPaths containsObject:path]) {
        [self.customPaths addObject:path];
    }
}

//初始化默认方法
- (id)init {
    return [self initWithNamespace:@"default"];
}

- (id)initWithNamespace:(NSString *)ns {
    //获取路径，再初始化
    NSString *path = [self makeDiskCachePath:ns];
    return [self initWithNamespace:ns diskCacheDirectory:path];
}

- (id)initWithNamespace:(NSString *)ns diskCacheDirectory:(NSString *)directory {
    if ((self = [super init])) {
        NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];

        // initialise PNG signature data
        //初始化PNG图片的标签数据
        kPNGSignatureData = [NSData dataWithBytes:kPNGSignatureBytes length:8];

        // Create IO serial queue
        //创建 serial queue
        _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);

        // Init default values
        //默认存储时间一周
        _maxCacheAge = kDefaultCacheMaxCacheAge;

        // Init the memory cache
        //初始化内存cache对象
        _memCache = [[AutoPurgeCache alloc] init];
        _memCache.name = fullNamespace;

        // Init the disk cache
        //初始化硬盘缓存路径
        if (directory != nil) {
            _diskCachePath = [directory stringByAppendingPathComponent:fullNamespace];
        } else {
            //默认路径
            NSString *path = [self makeDiskCachePath:ns];
            _diskCachePath = path;
        }

        // Set decompression to YES
        //需要压缩图片
        _shouldDecompressImages = YES;

        // memory cache enabled
        //需要cache在内存
        _shouldCacheImagesInMemory = YES;

        // Disable iCloud
        //禁止icloud
        _shouldDisableiCloud = YES;

        dispatch_sync(_ioQueue, ^{
            _fileManager = [NSFileManager new];
        });

#if TARGET_OS_IOS
        // Subscribe to app events
        //app相关warning，包括内存warning，app关闭notification，到后台notification
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(clearMemory)
                                                     name:UIApplicationDidReceiveMemoryWarningNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(cleanDisk)
                                                     name:UIApplicationWillTerminateNotification
                                                   object:nil];

        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(backgroundCleanDisk)
                                                     name:UIApplicationDidEnterBackgroundNotification
                                                   object:nil];
#endif
    }

    return self;
}

其中需要说一下的是kPNGSignatureData，它是用来判断是否是PNG图片的前缀标签数据，它的初始化数据kPNGSignatureBytes的来源如下：

// PNG图片的标签值
static unsigned char kPNGSignatureBytes[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};

存储图片

存储图片主要分为2块：

存储到内存
直接计算图片大小后，用NSCache *memCache存储
存储到硬盘
先将UIImage转为NSData，然后通过NSFileManager *_fileManager创建存储路径文件夹和图片存储文件

读取图片

读取图片主要分为两步：

内存cache读取
直接读取内存cacheself.memCache
硬盘图片读取
先从内存读取cache，如果不存在，则从硬盘读取，并且有必要的情况下存储到内存cache中

删除图片

删除图片方法分为两步：

先从cache删除缓存图片
然后硬盘删除对应文件

删除缓存

删除缓存也分为两块：

直接清空缓存memCache
删除硬盘存储目录，再重新创建目录

清理缓存

清理缓存的目标是将过期的图片和确保硬盘存储大小小于最大存储许可。
清理缓存的方法也是分为两步：

清除所有过期图片
在硬盘存储大小大于最大存储许可大小时，将旧图片进行删除，删除到一半最大许可以下

获取硬盘缓存大小

获取硬盘缓存大小直接读取硬盘路径下的文件数量和每个文件大小，进行累加。
相关方法如下：

typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger totalSize);
//获得硬盘存储空间大小
- (NSUInteger)getSize;

//获得硬盘空间图片数量
- (NSUInteger)getDiskCount;

//异步计算硬盘空间大小
- (void)calculateSizeWithCompletionBlock:(SDWebImageCalculateSizeBlock)completionBlock;

//获取硬盘存储的大小
- (NSUInteger)getSize {
    __block NSUInteger size = 0;
    dispatch_sync(self.ioQueue, ^{
        //硬盘路径迭代器
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
        for (NSString *fileName in fileEnumerator) {
            //拼接路径
            NSString *filePath = [self.diskCachePath stringByAppendingPathComponent:fileName];
            //获取路径下的文件与文件夹属性
            NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
            //算大小
            size += [attrs fileSize];
        }
    });
    return size;
}

//获取硬盘存储的数量
- (NSUInteger)getDiskCount {
    __block NSUInteger count = 0;
    dispatch_sync(self.ioQueue, ^{
        //硬盘路径迭代器
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
        count = [[fileEnumerator allObjects] count];
    });
    return count;
}

//异步获取硬盘缓存大小
- (void)calculateSizeWithCompletionBlock:(SDWebImageCalculateSizeBlock)completionBlock {
    NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];

    dispatch_async(self.ioQueue, ^{
        NSUInteger fileCount = 0;
        NSUInteger totalSize = 0;
        
        //迭代所有路径下文件
        NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:@[NSFileSize]
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];
        //遍历文件和文件夹
        for (NSURL *fileURL in fileEnumerator) {
            NSNumber *fileSize;
            //获取size
            [fileURL getResourceValue:&fileSize forKey:NSURLFileSizeKey error:NULL];
            totalSize += [fileSize unsignedIntegerValue];
            fileCount += 1;
        }

        if (completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock(fileCount, totalSize);
            });
        }
    });
}

判断key是否存在在硬盘

判断key是否存在在硬盘中，直接从硬盘中判断是否存在此key的文件路径
相关方法如下：

typedef void(^SDWebImageCheckCacheCompletionBlock)(BOOL isInCache);
//异步判断是否存在key的图片
- (void)diskImageExistsWithKey:(NSString *)key completion:(SDWebImageCheckCacheCompletionBlock)completionBlock;

//同步判断是否存在key的图片
- (BOOL)diskImageExistsWithKey:(NSString *)key;

//直接读取
- (BOOL)diskImageExistsWithKey:(NSString *)key {
    BOOL exists = NO;
    
    // this is an exception to access the filemanager on another queue than ioQueue, but we are using the shared instance
    // from apple docs on NSFileManager: The methods of the shared NSFileManager object can be called from multiple threads safely.
    exists = [[NSFileManager defaultManager] fileExistsAtPath:[self defaultCachePathForKey:key]];

    // fallback because of https://github.com/rs/SDWebImage/pull/976 that added the extension to the disk file name
    // checking the key with and without the extension
    if (!exists) {
        exists = [[NSFileManager defaultManager] fileExistsAtPath:[[self defaultCachePathForKey:key] stringByDeletingPathExtension]];
    }
    
    return exists;
}

//判断是否有key的文件
- (void)diskImageExistsWithKey:(NSString *)key completion:(SDWebImageCheckCacheCompletionBlock)completionBlock {
    dispatch_async(_ioQueue, ^{
        //直接去读默认文件
        BOOL exists = [_fileManager fileExistsAtPath:[self defaultCachePathForKey:key]];

        // fallback because of https://github.com/rs/SDWebImage/pull/976 that added the extension to the disk file name
        // checking the key with and without the extension
        
        //不存在去读区去掉path extension的方式
        if (!exists) {
            exists = [_fileManager fileExistsAtPath:[[self defaultCachePathForKey:key] stringByDeletingPathExtension]];
        }
        
        //回调block
        if (completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock(exists);
            });
        }
    });
}

总结

SDWebImage本身牵扯到很多内容，这篇文章先整体讲了一下SDImageCache的设计与实现，它有如下优点：

1.memory的cache和硬盘存储结合存储
2.后台清理硬盘存储空间
3.NSURL的文件读取用途和相关文件夹迭代器和获取
4.精妙的kPNGSignatureData判断是否是PNG图片
5.分别提供同步和异步的方法

当然也有一个path extension文件名问题。
这也告诉我们一个道理，很多时候文件名一定要想好怎么去存储，一旦进行修改了，后续兼容会很麻烦。

其他

本来是想SDWebImage解析完后与YYWebImage对比一下的，但既然都已经分文章去单独写了SDImageCache了，下篇文章就先解析YYCache。

看了看YYCache的源代码，确实比较长，还是先把SDWebImage分析完。

参考资料

1.Avoiding Image Decompression Sickness
2.SDWebImage源码浅析