阅读 536

Kingfisher源码解析之ImageCache

Kingfisher源码解析系列,由于水平有限,哪里有错,肯请不吝赐教

Kingfisher中ImageCache里提供内存缓存和磁盘缓存,分别是MemoryStorage.Backend<KFCrossPlatformImage>DiskStorage.Backend<Data>来实现的,注:内存缓存和磁盘缓存都是通过class Backend,不过这2个类,是完全不同的类,使用枚举来充当命名空间来区分的,分别定义在MemoryStorage.swiftDiskStorage.swift

内存缓存

内存缓存一共有三个类构成,Backend提供缓存的功能,Config提供缓存的配置项,StorageObject<T>缓存的封装类型

Config的主要内容
public struct Config {
    //内存缓存的最大容量,ImageCache.default中提供的默认值是设备物理内存的四分之一
    public var totalCostLimit: Int
    //内存缓存的最大长度
    public var countLimit: Int = .max
    //内存缓存的的过期时长
    public var expiration: StorageExpiration = .seconds(300)
    //清除过期缓存的时间间隔
    public let cleanInterval: TimeInterval
}
复制代码
StorageObject<T>的主要内容
class StorageObject<T> {
      //缓存的真正的值
      let value: T
      //存活时间,也就是多久之后过期
      let expiration: StorageExpiration
      //缓存e的key
      let key: String
      //过期时间,默认值是当前时间加上expiration
      private(set) var estimatedExpiration: Date
      // 更新过期时间
      func extendExpiration(_ extendingExpiration: ExpirationExtending = .cacheTime) {
          switch extendingExpiration {
          case .none://不更新过期时间
              return
          case .cacheTime://把过期时间设置为当前时间加上存活时间
              self.estimatedExpiration = expiration.estimatedExpirationSinceNow
          case .expirationTime(let expirationTime)://把过期时间设置为指定时间
              self.estimatedExpiration = expirationTime.estimatedExpirationSinceNow
          }
      }
      // 是否已经过期
      var expired: Bool {
          //estimatedExpiration.isPast 是对Date的一个扩展方法,判断estimatedExpiration是否小于当前时间
          return estimatedExpiration.isPast
      }
}
复制代码
Backend的主要内容
public class Backend<T: CacheCostCalculable> {
    //使用NSCache进行缓存
    let storage = NSCache<NSString, StorageObject<T>>()
    //存放所有缓存的key,在删除过期缓存是有用
    var keys = Set<String>()
    //定时器,用于定时清除过期数据
    private var cleanTimer: Timer? = nil
    //配置项
    public var config: Config
    ...下面还有一些缓存数据,读取数据,删除缓存,是否已缓存,删除过期数据等方法
}
复制代码

由上面我们可以看出,Kingfisher中内存缓存是用NSCache实现的,NSCache是一个类似于Dictionary的类,拥有相似的API,不过区别于Dictionary的是,NSCache是线程安全的,并且提供了设置最大缓存个数和最大缓存大小的配置,Backend就是通过设置NSCache的countLimittotalCostLimit来实现最大缓存个数和最大缓存大小。

通过下面的代码,看下Backend是如何缓存数据,读取数据,判断是否已缓存,删除缓存,删除过期数据的?代码中有详细的注释,注:下面的代码删除了一些非核心代码,比如异常,加锁保证线程安全等

缓存数据
func store(value: T,forKey key: String,expiration: StorageExpiration? = nil) {
    //获取存活时间,若缓存时没设置,则从配置中获取
    let expiration = expiration ?? config.expiration
    //判断是否过期,若已经过期直接返回
    guard !expiration.isExpired else { return }
    //把要缓存的值封装成StorageObject类型
    let object = StorageObject(value, key: key, expiration: expiration)
    //把结果缓存起来
    storage.setObject(object, forKey: key as NSString, cost: value.cacheCost)
    //把key保存起来
    keys.insert(key)
}
复制代码
读取数据,判断数据是否已缓存
// 读取数据
func value(forKey key: String, extendingExpiration: ExpirationExtending = .cacheTime) -> T? {
    //从NSCache中获取数据,如获取不到直接返回nil
    guard let object = storage.object(forKey: key as NSString) else { return nil }
    //判断是否过期,若过期直接返回nil
    if object.expired { return nil }
    //去更新过期时间
    object.extendExpiration(extendingExpiration)
    return object.value
}
// 判断是否缓存,其本质就是去读取数据,只是不更新缓存时间,若取到,则已缓存,否则未缓存
func isCached(forKey key: String) -> Bool {
    guard let _ = value(forKey: key, extendingExpiration: .none) else {
        return false
    }
    return true
}
复制代码
删除缓存
 func remove(forKey key: String) throws {
    storage.removeObject(forKey: key as NSString)
    keys.remove(key)
}
复制代码
删除过期数据,这里使用Set存储key的原因是NSCache,并没有像Dictionary一样提供获取allKeys或allValues的方法
func removeExpired() {
    for key in keys {
        let nsKey = key as NSString
        //通过key获取数据,若获取失败,则删除从keys中删除key
        guard let object = storage.object(forKey: nsKey) else {
            keys.remove(key)
            continue
        }
        //判断object是否过期,若过期,则从cache中删除数据,从keys中删除key
        if object.estimatedExpiration.isPast {
            storage.removeObject(forKey: nsKey)
            keys.remove(key)
        }
    }
}
复制代码

磁盘缓存

Kingfisher中磁盘缓存是通过文件系统来实现的,也就是说每个缓存的数据都对应一个文件,其中Kingfisher把文件的创建时间修改为最后一次读取的时间,把文件的修改时间修改为过期时间。

磁盘缓存一共有三个类构成,Backend提供缓存的功能,Config提供缓存的配置项,FileMeta存储着文件信息。

Config的主要内容
public struct Config {
    //磁盘缓存占用磁盘的最大值,为0z时,表示不限制
    public var sizeLimit: UInt
    //存活时间
    public var expiration: StorageExpiration = .days(7)
    //文件的扩展名
    public var pathExtension: String? = nil
    //是否需要把文件名哈希
    public var usesHashedFileName = true
    //操作文件的FileManager
    let fileManager: FileManager
    //文件缓存所在的文件夹,默认在cache文件夹里
    let directory: URL?
}

复制代码
FileMeta的主要内容
struct FileMeta {
    //文件路径
    let url: URL
    //文件最后一次读取时间
    //这个在超过sizeLimit大小时,需要删除文件时,用此属性进行排序,把时间较早的删除掉
    let lastAccessDate: Date?
    //过期时间
    let estimatedExpirationDate: Date?
    //是否是个文件夹
    let isDirectory: Bool
    //文件大小
    let fileSize: Int
}
复制代码
Backend的主要内容
public class Backend<T: DataTransformable> {
    //配置信息
    public var config: Config
    //写入文件所在的文件夹,默认在cache文件夹里
    public let directoryURL: URL
    //修改文件原信息时,所在的队列
    let metaChangingQueue: DispatchQueue
     //该方法会在init着调用,保证directoryURLs文件夹,已经被创建过了
    func prepareDirectory() throws {
        let fileManager = config.fileManager
        let path = directoryURL.path
        guard !fileManager.fileExists(atPath: path) else { return }
        try fileManager.createDirectory(atPath: path,withIntermediateDirectories: true,attributes: nil)
    }
    ...下面还有缓存数据,读取数据,判断是否已缓存,删除缓存,删除过期缓存,删除超过sizeLimit的缓存,统计缓存大小等
}
复制代码

通过下面的代码看Backend是如何缓存数据,读取数据,判断是否已缓存,删除缓存,删除过期缓存,删除超过sizeLimit的缓存,统计缓存大小以及如何通过key生成文件名的?代码中有详细的注释。注:下面的代码删除了一些非核心代码,比如异常,加锁保证线程安全等

通过key生成文件名

下面那段代码和源码中不太一样,但逻辑是一样的,我改成这样是因为方面我描述

//首先判断是否使用key的MD5值当做文件名,若是,则把filename设置成key.MD5
//然后再判断是否设置了扩展名,若设置了,则把扩展名拼接到filename上
func cacheFileName(forKey key: String) -> String {
    var filename = key
    if config.usesHashedFileName {
        filename = key.kf.md5
    } 
    if let ext = config.pathExtension {
        filename =  "\(filename).\(ext)"
    }
    return filename
}
复制代码
缓存数据
    func store(
        value: T,
        forKey key: String,
        expiration: StorageExpiration? = nil) throws
    {
        //获取存活时间,若缓存时没设置,则从配置中获取
        let expiration = expiration ?? config.expiration
         //判断是否过期,若已经过期直接返回
        guard !expiration.isExpired else { return }
        // 把value转成data,这里value类型是DataTransformable,需要实现toData等其他方法
        let data: try value.toData()
        //通过cacheKeyc生成一个完整的路径
        //完整的路径等于directoryURL+filename
        let fileURL = cacheFileURL(forKey: key)
        let now = Date()
        //把当前时间设置为文件的创建时间,把过期时间设置为文件的修改时间
        let attributes: [FileAttributeKey : Any] = [
            .creationDate: now.fileAttributeDate,
            .modificationDate: expiration.estimatedExpirationSinceNow.fileAttributeDate
        ]
        //通过fileManager把data写入文件
        config.fileManager.createFile(atPath: fileURL.path, contents: data, attributes: attributes)
    }
复制代码

上面代码中给文件设置创建时间和修改时间用的是给Date扩展的计算属性fileAttributeDate,fileAttributeDate返回的是Date(timeIntervalSince1970: ceil(timeIntervalSince1970)),也就是说把date的秒值向上取整后再转成date,为什么要这么做呢?作者解释说,date在内容中实际是一个double类型的值,而在file的属性中,只接受Int类型的值,会默认舍去小数部分,会导致对测试不友好,所以就改成这样了,我不是很理解为什么对测试不友好,难道是会导致提前一会结束过期吗?

加载缓存
    func value(
        forKey key: String,/
        referenceDate: Date,
        actuallyLoad: Bool,
        extendingExpiration: ExpirationExtending) throws -> T?
    {
        let fileManager = config.fileManager
        //通过cacheKeyc生成一个完整的路径
        let fileURL = cacheFileURL(forKey: key)
        let filePath = fileURL.path
        //判断是否存在该文件是否存在
        guard fileManager.fileExists(atPath: filePath) else {
            return nil
        }
        //通过fileURL生成一个FileMeta文件描述信息的类
        let resourceKeys: Set<URLResourceKey> = [.contentModificationDateKey, .creationDateKey]
        let meta = try FileMeta(fileURL: fileURL, resourceKeys: resourceKeys)
        //判断文件的过期时间是否大于referenceDate
        if meta.expired(referenceDate: referenceDate) {
            return nil
        }
        //判断是否是真的需要去加载数据,比如判断是否已缓存的时候,就不需要真的去加载,只要知道有就好了
        if !actuallyLoad { return T.empty }
        //读取文件
        let data = try Data(contentsOf: fileURL)
        let obj = try T.fromData(data)
        //更新文件的描述信息,本质也是为了h更新最后一次的读取时间和过期时间
        metaChangingQueue.async { meta.extendExpiration(with: fileManager, extendingExpiration: extendingExpiration) }
    }
复制代码
判断是否已缓存

通过调用value方法,判断value的返回值是否为nil,调用时会把actuallyLoad参数传为false,这样就不会去读取文件

通过key删除缓存,以及删除所有缓存
//通过key生成URL,然后把该文件删除
func remove(forKey key: String) throws {
    let fileURL = cacheFileURL(forKey: key)
    config.fileManager.removeItem(at: url)
}
//直接把文件夹删除
func removeAll(skipCreatingDirectory: Bool) throws {
    try config.fileManager.removeItem(at: directoryURL)
    if !skipCreatingDirectory {
        try prepareDirectory()
    }
}
复制代码
获取缓存大小

获取文件夹下的所有文件,并把每个文件的大小加起来

删除过期的缓存
    //删除在指定时间过期的缓存,若传入当前时间,则是删除现在已经过期的文件
    //返回值:删除的文件路径 
    func removeExpiredValues(referenceDate: Date = Date()) throws -> [URL] {
        let propertyKeys: [URLResourceKey] = [
            .isDirectoryKey,
            .contentModificationDateKey
        ]
        //获取所有的文件URL
        let urls = try allFileURLs(for: propertyKeys)
        let keys = Set(propertyKeys)
        //过滤出过期的文件URL
        let expiredFiles = urls.filter { fileURL in
            let meta = FileMeta(fileURL: fileURL, resourceKeys: keys)
            if meta.isDirectory {
                return false
            }
            return meta.expired(referenceDate: referenceDate)
        }
        //遍历所有的过期的文件UR,依次删除它们
        try expiredFiles.forEach { url in
            try removeFile(at: url)
        }
        return expiredFiles
    }
复制代码
缓存大小超过sizeLimit时删除缓存
  func removeSizeExceededValues() throws -> [URL] {
        //如果sizeLimit == 0代表不限制大小,直接返回
        if config.sizeLimit == 0 { return [] } 
        var size = try totalSize()
        //如果当前的缓存大小小于sizeLimit直接返回
        if size < config.sizeLimit { return [] }
        let urls = 获取所有的URLs
        //通过urls生成所有的文件信息,这里包含的信息有是否是文件夹,创建时间,和文件大小
        var pendings: [FileMeta] = urls.compactMap { fileURL in
            guard let meta = try? FileMeta(fileURL: fileURL, resourceKeys: keys) else {
                return nil
            }
            return meta
        }
        //通过创建时间排序,也就是通过最后一次的读取时间
        pendings.sort(by: FileMeta.lastAccessDate)
        var removed: [URL] = []
        let target = config.sizeLimit / 2
        //直到当前缓存大小小于sizeLimit的2分之一,否则按照最后的读取时间一次删除
        while size > target, let meta = pendings.popLast() {
            size -= UInt(meta.fileSize)
            try removeFile(at: meta.url)
            removed.append(meta.url)
        }
        return removed
    }
复制代码

补充

在ImageCache里监听了三个通知,分别是收到内存警告,应用即将被杀死,应用已经进入到后台,在这三个通知里分别做了,清空内存缓存,异步的清除磁盘过期缓存和磁盘大小超过simeLimit清除缓存,在后台清除磁盘过期缓存和磁盘大小超过simeLimit清除缓存

关注下面的标签,发现更多相似文章
评论