Swift：缓存Codable数据

韦弦zhy

发布于 2020-03-20 15:11:59

1.5K0

发布于 2020-03-20 15:11:59

我们的大多数应用程序都是某些后端的REST客户端。在开发此类应用程序期间，我们希望使其保持脱机状态。在这种情况下，我们必须将数据缓存在设备本地的某处，以使其无需互联网即可读取。

Apple提供了CoreData框架，这是在本地存储应用程序数据的最佳方法。它具有许多出色的功能，可帮助您促进开发。但是，很难将其用作简单的缓存。大多数时候，我们只需要显示缓存的数据，而无需任何其他操作。我认为，我们所需要的只是纯磁盘存储。本周，我们将讨论如何轻松地为Codable结构实现简单的磁盘存储。

CodableStorage

首先，为我们的存储逻辑定义几个协议。我想分开访问存储的可写和可读部分，这是我们可以使用Swift语言的协议组合功能的地方。

import Foundation

typealias Handler<T> = (Result<T, Error>) -> Void

protocol ReadableStorage {
    func fetchValue(for key: String) throws -> Data
    func fetchValue(for key: String, handler: @escaping Handler<Data>)
}

protocol WritableStorage {
    func save(value: Data, for key: String) throws
    func save(value: Data, for key: String, handler: @escaping Handler<String>)
}

typealias Storage = ReadableStorage & WritableStorage

首先，让我们描述一些用于存储的根路径的变量，用于异步工作的DispatchQueue和FileManager，我们将使用它们来浏览文件系统。

class DiskStorage {
    private let path: URL
    private let queue: DispatchQueue
    private let fileManager: FileManager
    
    init(
        path: URL,
        queue: DispatchQueue = .init(label: "DiskCache.Queue"),
        fileManager: FileManager = FileManager.default
    ) {
        self.path = path
        self.queue = queue
        self.fileManager = fileManager
    }
    
    private func createFolders(in url: URL) throws {
        let folderUrl = url.deletingLastPathComponent()
        if !fileManager.fileExists(atPath: folderUrl.path) {
            try fileManager.createDirectory(
                at: folderUrl,
                withIntermediateDirectories: true,
                attributes: nil)
        }
    }
}

下一步是实现我们存储的可写部分。这有点棘手，因为key是文件系统上数据的路径。因此，我们需要将ke'y附加到根路径并生成用于存储数据的新URL。新URL可以包含子文件夹，这就是我们创建createFolders函数的原因，该函数根据路径创建所需的文件夹。

extension DiskStorage: WritableStorage {
    func save(value: Data, for key: String) throws {
        let url = path.appendingPathComponent(key)
        do {
            try self.createFolders(in: url)
            try value.write(to: url, options: .atomic)
        } catch {
            throw StorageError.cantWrite(error)
        }
    }
}

这是存储协议的可读部分，我们在其中为传递的key实现数据获取。同样，我们使用key作为磁盘上数据的路径。

extension DiskStorage: ReadableStorage {
    func fetchValue(for key: String) throws -> Data {
        let url = path.appendingPathComponent(key)
        guard let data = fileManager.contents(atPath: url.path) else {
            throw StorageError.notFound
        }
        return data
    }
}

现在我们有了一个简单的磁盘存储的工作示例。下一步是为我们的DiskStorage类实现一个简单的适配器，该适配器将处理JSON编码/解码。

class CodableStorage {
    private let path: URL
    private var storage: DiskStorage
    private let decoder: JSONDecoder
    private let encoder: JSONEncoder
    
    init(
        path: URL = URL(fileURLWithPath:  NSTemporaryDirectory()),
        decoder: JSONDecoder = .init(),
        encoder: JSONEncoder = .init()
    ) {
        self.path = path
        self.storage = DiskStorage(path: path)
        self.decoder = decoder
        self.encoder = encoder
    }
    
    func fetch<T: Decodable>(for key: String) throws -> T {
        let data = try storage.fetchValue(for: key)
        return try decoder.decode(T.self, from: data)
    }
    
    func save<T: Encodable>(_ value: T, for key: String) throws {
        let data = try encoder.encode(value)
        try storage.save(value: data, for: key)
    }
}

CodableStorage类包装我们的DiskStorage类以添加JSON编解码逻辑。它使用通用约束来了解如何解码和编码数据。现在该在实际示例中使用我们的CodableStorage了。

#### 使用示例：

struct Timeline: Codable {
    let tweets: [String]
}

let storage = CodableStorage()

let timeline = Timeline(tweets: ["Hello", "World", "!!!"])

// -----同步：-----

//写
do {
    try storage.save(timeline, for: "timeline")
} catch  {
    print(error)
}

//读
if let cached: Timeline = try? storage.fetch(for: "timeline")  {
    print(cached)
}

//读
do {
    let cached: Timeline = try storage.fetch(for: "timeline")
    print(cached)
} catch {
    print(error)
}

//删单个
do {
    try storage.delete(for: "timeline")
} catch  {
    print(error)
}

//删所有
do {
    try storage.deleteAll()
} catch  {
    print(error)
}

// -----异步：-----

//存
storage.asyncSave(timeline, for: "timeline") { result in
    switch result {
    case .success(let key):
        print("async save \(key) success")
    case .failure(let error):
        print(error)
    }
}

//取
storage.asyncFetch(for: "timeline") { (result: Result<Timeline, Error>) in
    switch result {
    case .success(let timeline):
        print(timeline)
    case .failure(let err):
        print(err)
    }
}

//删单个
storage.asyncDelete(for: "timeline") { (result) in
    switch result {
    case .success(_):
        print("删除成功")
    case .failure(let error):
        print(error)
    }
}

//删除全部
storage.asyncDeleteAll() { (result) in
    switch result {
    case .success(_):
        print("删除成功")
    case .failure(let error):
        print(error)
    }
}

在上面的代码示例中，您可以看到CodableStorage类的用法。Timeline是一个简单的遵循Codable协议的结构体，表示存储在CodableStorage中的字符串数组。

今天，我们讨论了一种可存储可编码结构的简单方法，该结构可通过REST API获取。有时候，我们不需要CoreData的复杂功能即可进行简单的JSON缓存，这足以实现磁盘存储。