您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

iOS 網路圖片緩存機制詳解

編輯:iOS 開發綜合

開發行動應用時,無論是 Android 還是 iOS,只要應用需要頻繁存取網路,就必須認真對待優化問題——流量、網速、記憶體都是限制。

最典型的例子就是列表頁的縮圖。如果每次滾動都去網路重新下載同一張圖,不但耗流量,畫面也會因為等待而卡頓。這就是為什麼需要圖片緩存。

緩存的處理步驟

1. 根據圖片 URL 查找記憶體中是否已有該圖,有則直接回傳,沒有則進入第二步
2. 查找實體儲存是否已有該圖,有則回傳,沒有則進入第三步
3. 從網路下載該圖,下載完成後同時存入記憶體與實體儲存,並回傳該圖

註:由於 URL 含有特殊字元且長度不固定,需先對 URL 做 MD5 或其他處理,才能作為檔名使用

三層結構的實作要點

1. 記憶體緩存
使用 NSMutableDictionary 儲存 UIImage,key 為該圖片的 URL(或其 MD5 值):

[memCache setObject:image forKey:key];

2. 實體緩存
使用 NSFileManager 把圖片寫入 Caches 目錄,並以處理過的 URL 作為檔名。

3. 網路下載
以非同步方式下載,完成後同時寫入 NSMutableDictionary 與實體儲存。

參考實作:SDImageCache

以下摘自 SDWebImage 的緩存類別,註解已補齊。

標頭檔:

@interface SDImageCache : NSObject {
    NSMutableDictionary *memCache;              // 記憶體緩存圖片
    NSString *diskCachePath;                    // 實體緩存路徑
    NSOperationQueue *cacheInQueue, *cacheOutQueue;
}

+ (SDImageCache *)sharedImageCache;

// 保存圖片
- (void)storeImage:(UIImage *)image forKey:(NSString *)key;

// 保存圖片,並選擇是否同時寫入實體儲存
- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk;

// 保存圖片,可直接把 NSData 寫入實體儲存
- (void)storeImage:(UIImage *)image imageData:(NSData *)data forKey:(NSString *)key toDisk:(BOOL)toDisk;

// 透過 key 取得 UIImage
- (UIImage *)imageFromKey:(NSString *)key;

// 記憶體取不到時,是否繼續在實體儲存中查找
- (UIImage *)imageFromKey:(NSString *)key fromDisk:(BOOL)fromDisk;

- (void)queryDiskCacheForKey:(NSString *)key delegate:(id <SDImageCacheDelegate>)delegate userInfo:(NSDictionary *)info;

- (void)removeImageForKey:(NSString *)key;   // 移除指定 key 的圖片
- (void)clearMemory;                          // 清除記憶體圖片
- (void)clearDisk;                            // 清除實體緩存
- (void)cleanDisk;                            // 清除過期的實體緩存

@end

實作檔:

@implementation SDImageCache

#pragma mark NSObject

- (id)init {
    if ((self = [super init])) {
        // 初始化記憶體緩存
        memCache = [[NSMutableDictionary alloc] init];

        // 初始化實體緩存路徑
        NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
        diskCachePath = [[[paths objectAtIndex:0] stringByAppendingPathComponent:@"ImageCache"] retain];

        if (![[NSFileManager defaultManager] fileExistsAtPath:diskCachePath]) {
            [[NSFileManager defaultManager] createDirectoryAtPath:diskCachePath
                                      withIntermediateDirectories:YES
                                                       attributes:nil
                                                            error:NULL];
        }

        // 初始化操作佇列,皆為序列執行
        cacheInQueue = [[NSOperationQueue alloc] init];
        cacheInQueue.maxConcurrentOperationCount = 1;
        cacheOutQueue = [[NSOperationQueue alloc] init];
        cacheOutQueue.maxConcurrentOperationCount = 1;

#if TARGET_OS_IPHONE
        // 訂閱 App 事件
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(clearMemory)
                                                     name:UIApplicationDidReceiveMemoryWarningNotification
                                                   object:nil];

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

- (void)dealloc {
    [memCache release], memCache = nil;
    [diskCachePath release], diskCachePath = nil;
    [cacheInQueue release], cacheInQueue = nil;
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    [super dealloc];
}

#pragma mark SDImageCache (class methods)

+ (SDImageCache *)sharedImageCache {
    if (instance == nil) {
        instance = [[SDImageCache alloc] init];
    }
    return instance;
}

#pragma mark SDImageCache (private)

// 建立指定 key 的檔案路徑
- (NSString *)cachePathForKey:(NSString *)key {
    const char *str = [key UTF8String];
    unsigned char r[CC_MD5_DIGEST_LENGTH];
    CC_MD5(str, (CC_LONG)strlen(str), r);
    NSString *filename = [NSString stringWithFormat:
        @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
        r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7],
        r[8], r[9], r[10], r[11], r[12], r[13], r[14], r[15]];

    return [diskCachePath stringByAppendingPathComponent:filename];
}

// 把 key 與 Data 寫入實體儲存
// keyAndData[0] -> key,keyAndData[1] -> data
- (void)storeKeyWithDataToDisk:(NSArray *)keyAndData {
    // 不能跨執行緒共用 defaultManager
    NSFileManager *fileManager = [[NSFileManager alloc] init];

    NSString *key = [keyAndData objectAtIndex:0];
    NSData *data = [keyAndData count] > 1 ? [keyAndData objectAtIndex:1] : nil;

    if (data) {
        // 有資料就直接寫入
        [fileManager createFileAtPath:[self cachePathForKey:key] contents:data attributes:nil];
    } else {
        // 沒有 data 時,把 UIImage 轉為 JPEG 後寫入
        UIImage *image = [[self imageFromKey:key fromDisk:YES] retain];
        if (image) {
#if TARGET_OS_IPHONE
            [fileManager createFileAtPath:[self cachePathForKey:key]
                                 contents:UIImageJPEGRepresentation(image, (CGFloat)1.0)
                               attributes:nil];
#endif
            [image release];
        }
    }

    [fileManager release];
}

// 通知委派
- (void)notifyDelegate:(NSDictionary *)arguments {
    NSString *key = [arguments objectForKey:@"key"];
    id <SDImageCacheDelegate> delegate = [arguments objectForKey:@"delegate"];
    NSDictionary *info = [arguments objectForKey:@"userInfo"];
    UIImage *image = [arguments objectForKey:@"image"];

    if (image) {
        [memCache setObject:image forKey:key];

        if ([delegate respondsToSelector:@selector(imageCache:didFindImage:forKey:userInfo:)]) {
            [delegate imageCache:self didFindImage:image forKey:key userInfo:info];
        }
    } else {
        if ([delegate respondsToSelector:@selector(imageCache:didNotFindImageForKey:userInfo:)]) {
            [delegate imageCache:self didNotFindImageForKey:key userInfo:info];
        }
    }
}

// 在實體儲存中查找圖片
- (void)queryDiskCacheOperation:(NSDictionary *)arguments {
    NSString *key = [arguments objectForKey:@"key"];
    NSMutableDictionary *mutableArguments = [[arguments mutableCopy] autorelease];

    UIImage *image = [[[UIImage alloc] initWithContentsOfFile:[self cachePathForKey:key]] autorelease];
    if (image) {
        [mutableArguments setObject:image forKey:@"image"];
    }

    [self performSelectorOnMainThread:@selector(notifyDelegate:)
                          withObject:mutableArguments
                       waitUntilDone:NO];
}

#pragma mark ImageCache

- (void)storeImage:(UIImage *)image imageData:(NSData *)data forKey:(NSString *)key toDisk:(BOOL)toDisk {
    if (!image || !key) {
        return;
    }

    // 先寫入記憶體
    [memCache setObject:image forKey:key];

    // 需要寫入實體儲存時,丟到背景佇列處理
    if (toDisk) {
        if (!data) return;
        NSArray *keyWithData = [NSArray arrayWithObjects:key, data, nil];
        [cacheInQueue addOperation:[[[NSInvocationOperation alloc] initWithTarget:self
                                                                        selector:@selector(storeKeyWithDataToDisk:)
                                                                          object:keyWithData] autorelease]];
    }
}

- (void)storeImage:(UIImage *)image forKey:(NSString *)key {
    [self storeImage:image imageData:nil forKey:key toDisk:YES];
}

- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk {
    [self storeImage:image imageData:nil forKey:key toDisk:toDisk];
}

- (UIImage *)imageFromKey:(NSString *)key {
    return [self imageFromKey:key fromDisk:YES];
}

- (UIImage *)imageFromKey:(NSString *)key fromDisk:(BOOL)fromDisk {
    if (key == nil) {
        return nil;
    }

    UIImage *image = [memCache objectForKey:key];

    // 記憶體沒有,且允許查找實體儲存時
    if (!image && fromDisk) {
        image = [[[UIImage alloc] initWithContentsOfFile:[self cachePathForKey:key]] autorelease];
        if (image) {
            [memCache setObject:image forKey:key];
        }
    }

    return image;
}

- (void)queryDiskCacheForKey:(NSString *)key delegate:(id <SDImageCacheDelegate>)delegate userInfo:(NSDictionary *)info {
    if (!delegate) return;

    if (!key) {
        if ([delegate respondsToSelector:@selector(imageCache:didNotFindImageForKey:userInfo:)]) {
            [delegate imageCache:self didNotFindImageForKey:key userInfo:info];
        }
        return;
    }

    // 先查記憶體
    UIImage *image = [memCache objectForKey:key];
    if (image) {
        // 命中就直接回呼,不必非同步
        if ([delegate respondsToSelector:@selector(imageCache:didFindImage:forKey:userInfo:)]) {
            [delegate imageCache:self didFindImage:image forKey:key userInfo:info];
        }
        return;
    }

    NSMutableDictionary *arguments = [NSMutableDictionary dictionaryWithCapacity:3];
    [arguments setObject:key forKey:@"key"];
    [arguments setObject:delegate forKey:@"delegate"];
    if (info) {
        [arguments setObject:info forKey:@"userInfo"];
    }

    [cacheOutQueue addOperation:[[[NSInvocationOperation alloc] initWithTarget:self
                                                                    selector:@selector(queryDiskCacheOperation:)
                                                                      object:arguments] autorelease]];
}

// 同時移除記憶體與實體儲存中的圖片
- (void)removeImageForKey:(NSString *)key {
    if (key == nil) return;
    [memCache removeObjectForKey:key];
    [[NSFileManager defaultManager] removeItemAtPath:[self cachePathForKey:key] error:nil];
}

// 清除記憶體緩存
- (void)clearMemory {
    [cacheInQueue cancelAllOperations];
    [memCache removeAllObjects];
}

// 清除實體緩存
- (void)clearDisk {
    [cacheInQueue cancelAllOperations];
    [[NSFileManager defaultManager] removeItemAtPath:diskCachePath error:nil];
    [[NSFileManager defaultManager] createDirectoryAtPath:diskCachePath
                              withIntermediateDirectories:YES
                                               attributes:nil
                                                    error:NULL];
}

// 清除過期緩存
- (void)cleanDisk {
    NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-cacheMaxCacheAge];
    NSDirectoryEnumerator *fileEnumerator = [[NSFileManager defaultManager] enumeratorAtPath:diskCachePath];
    for (NSString *fileName in fileEnumerator) {
        NSString *filePath = [diskCachePath stringByAppendingPathComponent:fileName];
        NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
        if ([[[attrs fileModificationDate] laterDate:expirationDate] isEqualToDate:expirationDate]) {
            [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil];
        }
    }
}

@end

設計上的幾個關鍵決策

為什麼用 MD5:URL 常含 /、?、& 等字元,直接當檔名會出問題,長度也可能超出檔案系統上限。雜湊之後固定是 32 字元十六進位字串,安全又整齊。

為什麼用兩個序列佇列:寫入與讀取實體磁碟都是 I/O 密集的慢操作。分成 inQueue 與 outQueue 且皆設為 maxConcurrentOperationCount = 1,可以避免同一張圖在讀寫時互相競爭,也讓磁碟存取的順序可控。

記憶體壓力處理:訂閱 UIApplicationDidReceiveMemoryWarningNotification 時清空記憶體緩存,是必要設計。若支援多工,也可在進入背景時一併清理,降低被系統終結的機率。

可以再加強的地方:現行版本沒有對 memCache 設定容量上限或成本限制。實務上建議改用 NSCache 並實作 NSCacheDelegate,讓系統在記憶體吃緊時自動回收,而不必依賴手動清理;同時也能透過 setTotalCostLimit: 控制上限。另外,cleanDisk 的過期判斷邏輯較為寬鬆,建議改以檔案的 NSFileModificationDate 直接比較,並加上定期觸發機制。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved