URLCache（iOS）。storeCachedResponse异步工作。如何捕捉完成？

Question

刚刚发现函数storeCachedResponse（_ cachedResponse：CachedURLResponse，用于请求：URLRequest）是异步工作的。也就是说，执行后不会立即返回结果。我没有在官方文档中找到对此的描述。参见示例：

cache = URLCache(memoryCapacity: 0, diskCapacity: 100 * 1024 * 1024, diskPath: "myCache")
let config = URLSessionConfiguration.default
config.requestCachePolicy = .returnCacheDataElseLoad
config.urlCache = cache
let session = URLSession(configuration: config)
session.dataTask(with: request, completionHandler: {[unowned self]
    (data, response, error) in

    if let data = data, let response = response, ((response as HTTPURLResponse)?.statusCode ?? 500) < 300 {
        let cachedData = CachedURLResponse(response: response, data: data)                                            
        self.cache.storeCachedResponse(cachedData, for: request)
        let testCachedData = self.cache.cachedResponse(for: request)
    }
}

理论上，testCachedData必须包含缓存的响应。但实际上包含的内容是：

testCachedData?.response.url // Ok
testCachedData?.isEmpty // false
testCachedData?.data // 0 bytes!!!

尽管testCachedData？.data表示它包含0个字节，但我们可以将此数据写入文件，并且此文件将包含实际数据，而不是0。如果深入本地缓存目录（〜/ Library / Caches / myApp / MyCache），则在cachedResponse调用之后立即在断点处暂停，我们可以看到带有缓存文件（fsCachedData）的文件夹尚不存在。现在让我们在storeCachedResponse和cachedResponse之间插入延迟：

cache = URLCache(memoryCapacity: 0, diskCapacity: 100 * 1024 * 1024, diskPath: "myCache")
let config = URLSessionConfiguration.default
config.requestCachePolicy = .returnCacheDataElseLoad
config.urlCache = cache
let session = URLSession(configuration: config)
session.dataTask(with: request, completionHandler: {[unowned self]
    (data, response, error) in

    if let data = data, let response = response, ((response as HTTPURLResponse)?.statusCode ?? 500) < 300 {
        let cachedData = CachedURLResponse(response: response, data: data)                                            
        self.cache.storeCachedResponse(cachedData, for: request)
        delay(5) // JUST 5 SEC DELAY
        let testCachedData = self.cache.cachedResponse(for: request)
    }
}

现在：

testCachedData?.response.url // Ok
testCachedData?.isEmpty // false
testCachedData?.data // contains bytes

因此，在5秒钟的延迟后，我们看到缓存的文件文件夹（fsCachedData）存在并且包含缓存的文件（例如D8A30D21-C8F1-4FCA-967E-F6B440998173）。

关键是如何捕获storeCachedResponse的完成？

创建缓存文件后，我将立即使用它们。而且，我将直接处理缓存的文件，这不是设置延迟的最佳解决方案。

Answer 1

其实我不明白为什么您在缓存后立即调用缓存的数据！我认为，如果存在数据，则应在请求带有会话的url之前调用缓存的数据，然后返回缓存的数据，否则从头开始请求。

例如 ：

private let allowedDiskSize = 100 * 1024 * 1024
private lazy var cache: URLCache = {
    return URLCache(memoryCapacity: 0, diskCapacity: allowedDiskSize, diskPath: "gifCache")
}()

typealias DownloadCompletionHandler = (Result<Data,Error>) -> ()

private func createAndRetrieveURLSession() -> URLSession {
    let sessionConfiguration = URLSessionConfiguration.default
    sessionConfiguration.requestCachePolicy = .returnCacheDataElseLoad
    sessionConfiguration.urlCache = cache
    return URLSession(configuration: sessionConfiguration)
}

private func downloadContent(fromUrlString: String, completionHandler: @escaping DownloadCompletionHandler) {

    guard let downloadUrl = URL(string: fromUrlString) else { return }
    let urlRequest = URLRequest(url: downloadUrl)
    // First try to fetching cached data if exist
    if let cachedData = self.cache.cachedResponse(for: urlRequest) {
        print("Cached data in bytes:", cachedData.data)
        completionHandler(.success(cachedData.data))

    } else {
        // No cached data, download content than cache the data
        createAndRetrieveURLSession().dataTask(with: urlRequest) { (data, response, error) in

            if let error = error {
                completionHandler(.failure(error))
            } else {

                let cachedData = CachedURLResponse(response: response!, data: data!)
                self.cache.storeCachedResponse(cachedData, for: urlRequest)

                completionHandler(.success(data!))
            }
        }.resume()
    }
}

和用法：

self.downloadContent(fromUrlString: ANY_URL, completionHandler: { (result) in

            switch result {
            case .success(let yourData):
                // handle data

            case .failure(let error):
                debugPrint(error.localizedDescription)
            }
 })

第一次它将从Web上获取数据，第二次请求将立即返回缓存的数据。