1. 简介
EGOCache 是一个简单、线程安全的基于健－值 （key-value ）的缓存框架，支持 NSString、UI/NSImage 和 NSData，也支持存储任何实现协议的类，可以设定缓存的过期时间（默认为1天）。只提供了磁盘缓存，没有提供内存缓存。
可带着两个问题阅读代码：EGOCache如何进行缓存的？又是如何检测缓存过期？
2. 代码剖析
- EGOCache 是个单例类，整个程序的应用周期只初始化一次。在init方法中初始化缓存目录：
- (instancetype)init {
NSString* cachesDirectory = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES)[0];
NSString* oldCachesDirectory = [[[cachesDirectory stringByAppendingPathComponent:[[NSProcessInfo processInfo] processName]] stringByAppendingPathComponent:@"EGOCache"] copy];
if([[NSFileManager defaultManager] fileExistsAtPath:oldCachesDirectory]) {
[[NSFileManager defaultManager] removeItemAtPath:oldCachesDirectory error:NULL];
}
cachesDirectory = [[[cachesDirectory stringByAppendingPathComponent:[[NSBundle mainBundle] bundleIdentifier]] stringByAppendingPathComponent:@"EGOCache"] copy];
return [self initWithCacheDirectory:cachesDirectory];
}
- 在（initWithCacheDirectory:）方法里，每次初始化EGOCache实例对象的时，会遍历一遍plist文件中所有已存在的缓存项，对每个缓存项的时间和当前时间作比较，缓存项的时间早于当前时间，则删除对应缓存文件，并删除 plist 文件中对应 key 的记录。
注意区分方法中的三个队列：_cacheInfoQueue同步队列，用于对缓存项的操作；_frozenCacheInfoQueue同步队列，用于对frozenCacheInfo的操作，frozenCacheInfo和_cacheInfo区别在于前者是不可变的，每次_cacheInfo内容有更新后都会同步给frozenCacheInfo，保证用户缓存项中读到的数据是没有正在操作的，保证了数据的安全、一致；_diskQueue并发队列，用于复制文件，写入文件数据，根据键移除文件。
全局并发同步队列没有开启新线程，串行执行。全局并发异步队列有开启新线程，可并发执行。
手动创建的串行同步队列没有开启新线程，串行执行。手动创建的串行异步队列有开启1个新线程，串行执行。
- (instancetype)initWithCacheDirectory:(NSString*)cacheDirectory {
if((self = [super init])) {
_cacheInfoQueue = dispatch_queue_create("com.enormego.egocache.info", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t priority = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(priority, _cacheInfoQueue);
_frozenCacheInfoQueue = dispatch_queue_create("com.enormego.egocache.info.frozen", DISPATCH_QUEUE_SERIAL);
priority = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(priority, _frozenCacheInfoQueue);
_diskQueue = dispatch_queue_create("com.enormego.egocache.disk", DISPATCH_QUEUE_CONCURRENT);
priority = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(priority, _diskQueue);
// 初始化目录
_directory = cacheDirectory;
// 读取缓存项信息
_cacheInfo = [[NSDictionary dictionaryWithContentsOfFile:cachePathForKey(_directory, @"EGOCache.plist")] mutableCopy];
if(!_cacheInfo) {
_cacheInfo = [[NSMutableDictionary alloc] init];
}
// 创建目录
[[NSFileManager defaultManager] createDirectoryAtPath:_directory withIntermediateDirectories:YES attributes:nil error:NULL];
// 获取当前时间的NSTimeInterval
NSTimeInterval now = [[NSDate date] timeIntervalSinceReferenceDate];
NSMutableArray* removedKeys = [[NSMutableArray alloc] init];
// 遍历plist文件的缓存项，对每个缓存项的时间和当前时间作比较：缓存项的时间早于当前时间，则删除对应缓存文件，并删除 plist 文件中对应 key 的记录
for(NSString* key in _cacheInfo) {
if([_cacheInfo[key] timeIntervalSinceReferenceDate] <= now) {
[[NSFileManager defaultManager] removeItemAtPath:cachePathForKey(_directory, key) error:NULL];
[removedKeys addObject:key];
}
}
[_cacheInfo removeObjectsForKeys:removedKeys];
// 保存plist文件的缓存项
self.frozenCacheInfo = _cacheInfo;
// 默认的缓存时间：1天
[self setDefaultTimeoutInterval:86400];
}
return self;
}
- 读取缓存数据：读取一个缓存项时，先会判断缓存项是否存在（hasCacheForKey:）；如缓存项存在，接着去判断读取到的缓存项的存储时间和当前时间相比是否过期（Why？有一些缓存项在EGOCache被初始化之后过期，依然可以读到这个缓存项，这就不对了。）；如果缓存项没有过期，则返回读取到的缓存项数据。
- (NSString*)stringForKey:(NSString*)key {
return [[NSString alloc] initWithData:[self dataForKey:key] encoding:NSUTF8StringEncoding];
}
- (NSData*)dataForKey:(NSString*)key {
// 缓存项是否存在
if([self hasCacheForKey:key]) {
return [NSData dataWithContentsOfFile:cachePathForKey(_directory, key) options:0 error:NULL];
} else {
return nil;
}
}
- (BOOL)hasCacheForKey:(NSString*)key {
NSDate* date = [self dateForKey:key];
if(date == nil) return NO;
// 缓存项是否过期
if([date timeIntervalSinceReferenceDate] < CFAbsoluteTimeGetCurrent()) return NO;
return [[NSFileManager defaultManager] fileExistsAtPath:cachePathForKey(_directory, key)];
}
- 清除缓存
根据键key删除文件（removeCacheForKey:）时避免要删的文件和存储本地的文件重名；然后在 并发异步队列中删除文件；设置缓存项时间（setCacheTimeoutInterval:forKey:），如果缓存时间存在，删除缓存项信息，否则根据键更新缓存时间。
清除缓存（clearCache）时在串行同步队列中进行，先删除文件，再删除缓存项信息。
- (void)removeCacheForKey:(NSString*)key {
// 删除文件时避免要删的文件和存储本地的文件重名
CHECK_FOR_EGOCACHE_PLIST();
dispatch_async(_diskQueue, ^{
[[NSFileManager defaultManager] removeItemAtPath:cachePathForKey(_directory, key) error:NULL];
});
[self setCacheTimeoutInterval:0 forKey:key];
}
- (void)clearCache {
dispatch_sync(_cacheInfoQueue, ^{
for(NSString* key in _cacheInfo) {
[[NSFileManager defaultManager] removeItemAtPath:cachePathForKey(_directory, key) error:NULL];
}
[_cacheInfo removeAllObjects];
dispatch_sync(_frozenCacheInfoQueue, ^{
self.frozenCacheInfo = [_cacheInfo copy];
});
[self setNeedsSave];
});
}
- (void)setCacheTimeoutInterval:(NSTimeInterval)timeoutInterval forKey:(NSString*)key {
NSDate* date = timeoutInterval > 0 ? [NSDate dateWithTimeIntervalSinceNow:timeoutInterval] : nil;
// Temporarily store in the frozen state for quick reads
// frozenCacheInfo存储的就是缓存项，便于快速读取
dispatch_sync(_frozenCacheInfoQueue, ^{
NSMutableDictionary* info = [self.frozenCacheInfo mutableCopy];
if(date) {
// 缓存日期存在，根据键更新缓存日期
info[key] = date;
} else {
// 缓存日期不存在，根据键在缓存项中移除
[info removeObjectForKey:key];
}
self.frozenCacheInfo = info;
});
// Save the final copy (this may be blocked by other operations)
dispatch_async(_cacheInfoQueue, ^{
if(date) {
_cacheInfo[key] = date;
} else {
[_cacheInfo removeObjectForKey:key];
}
dispatch_sync(_frozenCacheInfoQueue, ^{
self.frozenCacheInfo = [_cacheInfo copy];
});
// 将缓存项写入目录对应的文件EGOCache.plist
[self setNeedsSave];
});
}
- (void)setNeedsSave {
// 异步串行队列中进行
dispatch_async(_cacheInfoQueue, ^{
if(_needsSave) return;
_needsSave = YES;
double delayInSeconds = 0.5;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
dispatch_after(popTime, _cacheInfoQueue, ^(void){
if(!_needsSave) return;
[_cacheInfo writeToFile:cachePathForKey(_directory, @"EGOCache.plist") atomically:YES];
_needsSave = NO;
});
});
}
