能否指定缓存策略？Siesta是否支持LocalOnly、NetworkFirst缓存策略？

Great questions about Siesta's caching capabilities—let’s dive right in:

1. Can I specify custom cache policies in Siesta? #

Absolutely! Siesta is built with flexible caching control at its core. You’re not stuck with a rigid default setup:

• Define global cache policies for your entire API client to set app-wide behavior.
• Override policies for specific resources or even individual requests to handle edge cases.
• Implement fully custom logic by conforming to CacheProtocol or extending the built-in CachePolicy to match your exact needs.

2. Does Siesta support LocalOnly and NetworkFirst cache strategies? #

Let’s break down each scenario:

LocalOnly (Fetch only from local cache, no network request) #

Siesta doesn’t have a pre-built LocalOnly policy, but it’s super straightforward to implement. You can directly access cached data without triggering any network calls:

// Example: Fetch exclusively from cache
if let cachedEntity = myResource.cachedEntity {
    // Use the cached data right away
    updateUI(with: cachedEntity)
} else {
    // Handle cases where no cache exists (e.g., show an empty state or error)
    displayNoCacheWarning()
}

For reusability, you could wrap this logic in a Resource extension to keep your code clean across the app.

NetworkFirst (Try network first, fall back to cache on failure) #

This is fully supported, and you can implement it in a couple of practical ways:

1. Inline request handling:
   Siesta’s default behavior returns cached data first while refreshing in the background, but for NetworkFirst, you can prioritize the network call and fall back to cache only if it fails:

   myResource.load { result in
       switch result {
       case .success(let entity):
           // Use fresh network data
           updateUI(with: entity)
       case .failure(let error):
           // Network failed—fall back to cache if available
           if let cachedEntity = myResource.cachedEntity {
               updateUI(with: cachedEntity)
           } else {
               // No cache + network failure: handle the error properly
               showNetworkError(error)
           }
       }
   }
   

2. Custom reusable CachePolicy:
   For a more scalable approach, define a policy that skips immediate cache use and only falls back when the network fails:

   let networkFirstPolicy = CachePolicy(
       allowsReuseOfCachedResponse: { _, _ in false },  // Don't use cache upfront
       shouldRequestRefresh: { _, _ in true },          // Always attempt network refresh
       stalenessInterval: TimeInterval.infinity         // Cache never expires (adjust as needed)
   )
   
   // Apply to a specific resource
   myResource.config.cachePolicy = networkFirstPolicy
   

内容的提问来源于stack exchange，提问作者RPallas