讀碼筆記-YYWebImage原始碼 (三) -YYImageCache

weixin_33850890發表於2016-01-09
筆記Web原始碼

這個類內容比較簡單,api也都 通俗易懂,僅僅把註釋貼上來即可,深究為什麼這麼簡單,其實還是因為這個類做的事情其實僅僅是統一的呼叫YYMemoryCache,YYMemoryCache來存取圖片而已,具體的儲存細節都實現在YYCache裡面了,所以這裡使用起來才會簡單輕鬆.

先看開放了哪些api,都是什麼意思

///圖片快取型別
typedef NS_OPTIONS(NSUInteger, YYImageCacheType) {
    /// No value.
    YYImageCacheTypeNone   = 0,
    
    /// Get/store image with memory cache.//從記憶體中獲取
    YYImageCacheTypeMemory = 1 << 0,
    
    /// Get/store image with disk cache.//從磁碟中獲取
    YYImageCacheTypeDisk   = 1 << 1,
    
    /// Get/store image with both memory cache and disk cache.//同時獲取
    YYImageCacheTypeAll    = YYImageCacheTypeMemory | YYImageCacheTypeDisk,
};

/**
 *  YYImageCache是一個用來儲存UIImage和image資料的快取,是基於記憶體快取與磁碟快取實現的
 
 @discussion 磁碟快取會嘗試保護原始的圖片資料
 如果原始的圖片仍是image,會儲存為一個png或者jpeg
 如果原始圖片是一個gif,apng,webp動圖,會儲存為原始格式
 如果原始圖片縮放比例不是1,那麼縮放值會被儲存為一個縮放的資料
 雖然圖片能被NSCoding協議解碼,但是這不是一個最優解:
 蘋果的確使用UIImagePNGRepresentation()來解碼所有型別的圖片,但是可能會丟失原始的可變幀資料.結果就是打包成plist檔案不能直接檢視照片.如果圖片沒有alpha通道,使用JPEG代理PNG能夠儲存更多的尺寸和編解碼時間.
 */
@interface YYImageCache : NSObject

//快取名字,預設為nil
@property (copy) NSString *name;

//記憶體快取,具體資訊看YYMemoryCache
@property (strong, readonly) YYMemoryCache *memoryCache;

//磁碟快取,具體資訊看YYDiskCache
@property (strong, readonly) YYDiskCache *diskCache;

/**
 *  當從磁碟快取請求圖片的時候是否解碼動圖,預設為YES
 @discussion 當從磁碟快取讀取圖片,會使用YYImage來解碼比如WebP/APNG/GIF格式的動圖,設定這個值為NO可以忽略動圖
 */
@property (assign) BOOL allowAnimatedImage;

/**
 *  是否解碼圖片儲存點陣圖,預設為YES
 @discussion 如果這個值為YES,圖片會通過點陣圖解碼來獲得更好的使用者體驗,但是可能會消耗更大的記憶體資源
 */
@property (assign) BOOL decodeForDisplay;


- (instancetype)init UNAVAILABLE_ATTRIBUTE;
+ (instancetype)new UNAVAILABLE_ATTRIBUTE;

/**
 *  單例類初始化方法
 */
+ (instancetype)sharedCache;

/**
 *  初始化方法,在多個情況下訪問同一個路徑會導致快取不穩定
 *
 *  @param path cache讀寫的全路徑,只初始化一次,你不應該來讀寫這個路徑
 *
 *  @return 一個新的快取物件,或者返回帶nil帶error資訊
 */
- (instancetype)initWithPath:(NSString *)path NS_DESIGNATED_INITIALIZER;


/**
 *  把圖片通過一個具體的key存進快取,同時memory跟disk都會存,這個方法會立刻返回,在後臺執行緒執行
 *
 *  @param image 如果為nil這個方法無效
 *  @param key 儲存圖片的key,為nil這個方法無效
 */
- (void)setImage:(UIImage *)image forKey:(NSString *)key;

/**
 *  通過一個key把圖片快取,這個方法會立刻返回並在後臺執行
    如果'type'包括'YYImageCacheTypeMemory',那麼圖片會被存進memory,如果image為nil會用'imageData'代理
    如果'type'包括'YYImageCacheTypeDisk',那麼'imageData'會被存進磁碟快取,如果'imageData'為nil會用image代替
 //這裡可以看到作者一個思想,如果存進memory,直接存image,會減小很多解碼的消耗,如果存disk,會存imageData
 *
 */
- (void)setImage:(UIImage *)image imageData:(NSData *)imageData forKey:(NSString *)key withType:(YYImageCacheType)type;

/**
 *  通過key移除cache中的一個圖片,memory跟disk會同時移除
    這個方法會立刻返回並在後臺執行緒執行
 *
 *  @param key 移除圖片用的key,為nil的話這個方法沒啥用
 */
- (void)removeImageForKey:(NSString *)key;

/**
 *  從快取中通過key刪圖片
 這個方法會立刻返回並在後臺執行緒執行
 *
 *  @param key  key
 *  @param type 從哪刪除,跟上個方法不同,這個可以刪除指定型別的快取
 */
- (void)removeImageForKey:(NSString *)key withType:(YYImageCacheType)type;

/**
 *  通過key檢查快取中是否有某個圖片
    如果圖片不在記憶體中,這個方法可能會阻塞執行緒,知道這個檔案讀取完畢
 *
 *  @param key key,為nil時返回NO
 *
 */
- (BOOL)containsImageForKey:(NSString *)key;

/**
 *  跟上個差不多,只不過可以查具體型別的快取
 */
- (BOOL)containsImageForKey:(NSString *)key withType:(YYImageCacheType)type;

/**
 *  通過key獲取圖片,如果圖片不在記憶體中,這個方法可能會阻塞執行緒知道檔案讀取完畢
 *
 *  @param key 一個字串型別圖片快取key,為nil方法返回nil
 *
 *  @return 通過key查到的圖片,沒有圖片就是nil
 */
- (UIImage *)getImageForKey:(NSString *)key;

/**
 *  跟上個方法差不多,只不過從指定快取型別中獲取圖片
 */
- (UIImage *)getImageForKey:(NSString *)key withType:(YYImageCacheType)type;

/**
 *  通過key非同步的獲取圖片
 *
 *  @param key   key
 *  @param type  快取型別
 *  @param block 完成的block回撥,主執行緒呼叫的
 */
- (void)getImageForKey:(NSString *)key withType:(YYImageCacheType)type withBlock:(void(^)(UIImage *image, YYImageCacheType type))block;

/**
 *  通過key查詢圖片資料data格式,方法會阻塞主執行緒知道檔案讀取完畢
 *
 *  @param key key
 *
 *  @return 圖片資料,查不到為nil
 */
- (NSData *)getImageDataForKey:(NSString *)key;

/**
 *  通過key來非同步的獲取圖片資料
 *
 *  @param key   <#key description#>
 *  @param block 主執行緒的完成回撥
 */
- (void)getImageDataForKey:(NSString *)key withBlock:(void(^)(NSData *imageData))block;

其實現細節如下:


static inline dispatch_queue_t YYImageCacheIOQueue() {
#ifdef YYDispatchQueuePool_h
    return YYDispatchQueueGetForQOS(NSQualityOfServiceDefault);
#else
    return dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
#endif
}

static inline dispatch_queue_t YYImageCacheDecodeQueue() {
#ifdef YYDispatchQueuePool_h
    return YYDispatchQueueGetForQOS(NSQualityOfServiceUtility);
#else
    return dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
#endif
}


@interface YYImageCache ()
- (NSUInteger)imageCost:(UIImage *)image;
- (UIImage *)imageFromData:(NSData *)data;
@end


@implementation YYImageCache

/**
 *  圖片消耗
 */
- (NSUInteger)imageCost:(UIImage *)image {
    CGImageRef cgImage = image.CGImage;
    if (!cgImage) return 1;
    CGFloat height = CGImageGetHeight(cgImage);
    size_t bytesPerRow = CGImageGetBytesPerRow(cgImage);
    NSUInteger cost = bytesPerRow * height;
    if (cost == 0) cost = 1;
    return cost;
}

/**
 *  通過data轉換為image
 */
- (UIImage *)imageFromData:(NSData *)data {
    NSData *scaleData = [YYDiskCache getExtendedDataFromObject:data];
    CGFloat scale = 0;
    if (scaleData) {
        scale = ((NSNumber *)[NSKeyedUnarchiver unarchiveObjectWithData:scaleData]).doubleValue;
    }
    if (scale <= 0) scale = [UIScreen mainScreen].scale;
    UIImage *image;
    if (_allowAnimatedImage) {
        image = [[YYImage alloc] initWithData:data scale:scale];
        if (_decodeForDisplay) image = [image yy_imageByDecoded];
    } else {
        YYImageDecoder *decoder = [YYImageDecoder decoderWithData:data scale:scale];
        image = [decoder frameAtIndex:0 decodeForDisplay:_decodeForDisplay].image;
    }
    return image;
}

#pragma mark Public
/**
 *  單例類的初始化方法
 */
+ (instancetype)sharedCache {
    static YYImageCache *cache = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSString *cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory,
                                                                   NSUserDomainMask, YES) firstObject];
        //拼接路徑
        cachePath = [cachePath stringByAppendingPathComponent:@"com.ibireme.yykit"];
        cachePath = [cachePath stringByAppendingPathComponent:@"images"];
        cache = [[self alloc] initWithPath:cachePath];
    });
    return cache;
}

- (instancetype)init {
    @throw [NSException exceptionWithName:@"YYImageCache init error" reason:@"YYImageCache must be initialized with a path. Use 'initWithPath:' instead." userInfo:nil];
    return [self initWithPath:nil];
}

/**
 *  在初始化的時候同時初始化記憶體快取跟磁碟快取
 *
 */
- (instancetype)initWithPath:(NSString *)path {
    //在呼叫父類init之前先初始化一個記憶體快取跟磁碟快取
    YYMemoryCache *memoryCache = [YYMemoryCache new];//生成記憶體快取
    memoryCache.shouldRemoveAllObjectsOnMemoryWarning = YES;//記憶體警告的時候刪除所有內容
    memoryCache.shouldRemoveAllObjectsWhenEnteringBackground = YES;//進入後臺刪除所有內容
    memoryCache.countLimit = NSUIntegerMax;//不予限制
    memoryCache.costLimit = NSUIntegerMax;//不予限制
    memoryCache.ageLimit = 12 * 60 * 60;//cache存在的時間限制設定為12個小時
    
    YYDiskCache *diskCache = [[YYDiskCache alloc] initWithPath:path];//生成磁碟快取
    diskCache.customArchiveBlock = ^(id object) { return (NSData *)object; };//自己來archive資料
    diskCache.customUnarchiveBlock = ^(NSData *data) { return (id)data; };//自己unarchive資料
    if (!memoryCache || !diskCache) return nil;//如果有任意一個初始化失敗,返回nil
    
    self = [super init];
    _memoryCache = memoryCache;
    _diskCache = diskCache;
    _allowAnimatedImage = YES;
    _decodeForDisplay = YES;
    return self;
}

- (void)setImage:(UIImage *)image forKey:(NSString *)key {
    [self setImage:image imageData:nil forKey:key withType:YYImageCacheTypeAll];
}

- (void)setImage:(UIImage *)image imageData:(NSData *)imageData forKey:(NSString *)key withType:(YYImageCacheType)type {
    //在每一個方法執行前先檢查引數的有效性,非常好的習慣
    if (!key || (image == nil && imageData.length == 0)) return;
    
    __weak typeof(self) _self = self;
    //如果型別有YYImageCacheTypeMemory
    if (type & YYImageCacheTypeMemory) { // add to memory cache
        if (image) {
            if (image.yy_isDecodedForDisplay) {
                //開啟了點陣圖解碼的話直接把圖片丟進記憶體快取裡面咯
                [_memoryCache setObject:image forKey:key withCost:[_self imageCost:image]];
            } else {
                //否則開啟一個非同步的解碼佇列,把圖片轉成點陣圖,再丟進快取裡面
                dispatch_async(YYImageCacheDecodeQueue(), ^{
                    __strong typeof(_self) self = _self;
                    if (!self) return;
                    [self.memoryCache setObject:[image yy_imageByDecoded] forKey:key withCost:[self imageCost:image]];
                });
            }
        } else if (imageData) {//如果圖片不存在,圖片資料存在,那就通過data生成一個圖片,丟進記憶體中存起來
            dispatch_async(YYImageCacheDecodeQueue(), ^{
                __strong typeof(_self) self = _self;
                if (!self) return;
                UIImage *newImage = [self imageFromData:imageData];
                [self.memoryCache setObject:[self imageFromData:imageData] forKey:key withCost:[self imageCost:newImage]];
            });
        }
    }
    //如果型別包含磁碟快取,存進磁碟
    if (type & YYImageCacheTypeDisk) { // add to disk cache
        if (imageData) {
            if (image) {
                [YYDiskCache setExtendedData:[NSKeyedArchiver archivedDataWithRootObject:@(image.scale)] toObject:imageData];
            }
            [_diskCache setObject:imageData forKey:key];
        } else if (image) {
            dispatch_async(YYImageCacheIOQueue(), ^{
                __strong typeof(_self) self = _self;
                if (!self) return;
                NSData *data = [image yy_imageDataRepresentation];
                [YYDiskCache setExtendedData:[NSKeyedArchiver archivedDataWithRootObject:@(image.scale)] toObject:data];
                [self.diskCache setObject:data forKey:key];
            });
        }
    }
}

/**
 *  全刪咯
 *
 */
- (void)removeImageForKey:(NSString *)key {
    [self removeImageForKey:key withType:YYImageCacheTypeAll];
}
//有哪個型別刪哪個
- (void)removeImageForKey:(NSString *)key withType:(YYImageCacheType)type {
    if (type & YYImageCacheTypeMemory) [_memoryCache removeObjectForKey:key];
    if (type & YYImageCacheTypeDisk) [_diskCache removeObjectForKey:key];
}

- (BOOL)containsImageForKey:(NSString *)key {
    return [self containsImageForKey:key withType:YYImageCacheTypeAll];
}

- (BOOL)containsImageForKey:(NSString *)key withType:(YYImageCacheType)type {
    if (type & YYImageCacheTypeMemory) {
        if ([_memoryCache containsObjectForKey:key]) return YES;
    }
    if (type & YYImageCacheTypeDisk) {
        if ([_diskCache containsObjectForKey:key]) return YES;
    }
    return NO;
}

- (UIImage *)getImageForKey:(NSString *)key {
    return [self getImageForKey:key withType:YYImageCacheTypeAll];
}

//通過key找圖片,都比較簡單
- (UIImage *)getImageForKey:(NSString *)key withType:(YYImageCacheType)type {
    if (!key) return nil;
    if (type & YYImageCacheTypeMemory) {
        UIImage *image = [_memoryCache objectForKey:key];
        if (image) return image;
    }
    if (type & YYImageCacheTypeDisk) {
        NSData *data = (id)[_diskCache objectForKey:key];
        UIImage *image = [self imageFromData:data];
        if (image && (type & YYImageCacheTypeMemory)) {
            [_memoryCache setObject:image forKey:key withCost:[self imageCost:image]];
        }
        return image;
    }
    return nil;
}

//跟上個方法類似,只不過把查詢的結果通過block傳遞了回去
- (void)getImageForKey:(NSString *)key withType:(YYImageCacheType)type withBlock:(void (^)(UIImage *image, YYImageCacheType type))block {
    if (!block) return;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        UIImage *image = nil;
        
        if (type & YYImageCacheTypeMemory) {
            image = [_memoryCache objectForKey:key];
            if (image) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    block(image, YYImageCacheTypeMemory);
                });
                return;
            }
        }
        
        if (type & YYImageCacheTypeDisk) {
            NSData *data = (id)[_diskCache objectForKey:key];
            image = [self imageFromData:data];
            if (image) {
                [_memoryCache setObject:image forKey:key];
                dispatch_async(dispatch_get_main_queue(), ^{
                    block(image, YYImageCacheTypeDisk);
                });
                return;
            }
        }
        
        dispatch_async(dispatch_get_main_queue(), ^{
            block(nil, YYImageCacheTypeNone);
        });
    });
}

- (NSData *)getImageDataForKey:(NSString *)key {
    return (id)[_diskCache objectForKey:key];
}

- (void)getImageDataForKey:(NSString *)key withBlock:(void (^)(NSData *imageData))block {
    if (!block) return;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSData *data = (id)[_diskCache objectForKey:key];
        dispatch_async(dispatch_get_main_queue(), ^{
            block(data);
        });
    });
}

@end

PS:
YYWebImage原始碼地址
我fork下來新增註釋的版本github地址

相關文章