EGOCache 源码剖析

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;
  });
 });
}