Cache em Swift (iOS/macOS): Redis, NSCache e Core Data

Cache em Swift (iOS/macOS): Redis e alternativas

Cache é um dos mecanismos-chave para otimizar o desempenho de aplicativos móveis e desktop em Swift. Ele permite reduzir o tempo de carregamento de dados, diminuir a carga no servidor e melhorar a experiência do usuário. Neste artigo, abordaremos as principais ferramentas de cache para iOS e macOS: desde soluções integradas (NSCache, URLCache) até integração com sistemas externos (Redis) e armazenamentos persistentes (Core Data).

1. Mecanismos de cache integrados

1.1 NSCache — cache rápido in-memory

NSCache é um cache thread-safe e de limpeza automática, ideal para armazenamento temporário de objetos que podem ser recriados (por exemplo, imagens ou resultados de parsing).

import Foundation

let imageCache = NSCache<NSString, UIImage>()

func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {    let cacheKey = url.absoluteString as NSString

    // Verifica o cache    if let cachedImage = imageCache.object(forKey: cacheKey) {        completion(cachedImage)        return    }

    // Carrega os dados    URLSession.shared.dataTask(with: url) { data, _, _ in        guard let data = data, let image = UIImage(data: data) else {            completion(nil)            return        }        // Salva no cache        imageCache.setObject(image, forKey: cacheKey)        completion(image)    }.resume()}

Características:

• Remove objetos automaticamente quando há falta de memória (suporta countLimit e totalCostLimit).
• Ideal para cache de imagens baixadas, respostas JSON de API.
• Não persiste dados entre execuções do aplicativo.

1.2 URLCache — cache de sistema para requisições HTTP

URLCache fornece cache transparente de requisições de rede no nível do sistema. Suporta armazenamento em disco e em memória.

let cache = URLCache(memoryCapacity: 50 * 1024 * 1024,   // 50 MB                     diskCapacity: 200 * 1024 * 1024,     // 200 MB                     diskPath: "myCache")URLCache.shared = cache

// Exemplo de requisição com cachelet request = URLRequest(url: URL(string: "https://api.example.com/data")!,                         cachePolicy: .returnCacheDataElseLoad,                         timeoutInterval: 30)URLSession.shared.dataTask(with: request) { data, response, error in    // Os dados serão automaticamente armazenados em cache}.resume()

Este método funciona bem para recursos estáticos (imagens, arquivos de configuração), mas não é adequado para dados dinâmicos que exigem atualização.

2. Cache persistente com Core Data

Se for necessário manter dados entre sessões do aplicativo, use Core Data ou SQLite (via GRDB.swift). Abaixo, um exemplo simples de cache com Core Data:

import CoreData

class CacheManager {    static let shared = CacheManager()    private let context: NSManagedObjectContext

    private init() {        // Configuração da pilha Core Data (simplificada)        let container = NSPersistentContainer(name: "CacheModel")        container.loadPersistentStores { _, error in            if let error = error { fatalError("Erro Core Data: \\(error)") }        }        context = container.viewContext    }

    func save(data: Data, forKey key: String) {        let entity = CachedItem(context: context)        entity.key = key        entity.data = data        entity.timestamp = Date()        try? context.save()    }

    func load(forKey key: String) -> Data? {        let fetch: NSFetchRequest<CachedItem> = CachedItem.fetchRequest()        fetch.predicate = NSPredicate(format: "key == %@", key)        let result = try? context.fetch(fetch)