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

Cache em Swift (iOS/macOS): de in-memory ao Redis

No desenvolvimento para iOS e macOS, o cache é uma ferramenta chave para acelerar a execução de aplicativos, reduzir a carga no servidor e melhorar a experiência do usuário. Neste artigo, abordaremos as principais abordagens de cache em Swift: desde o simples NSCache até soluções profissionais baseadas em Redis e SQLite. Cada método tem seu próprio escopo de aplicação, e a escolha correta depende do tipo de dados, seu volume e requisitos de persistência.

1. NSCache — cache in-memory integrado

NSCache é um cache leve e thread-safe integrado ao Foundation. Ele libera memória automaticamente quando há falta de recursos, tornando-o ideal para armazenar em cache imagens, dados de API e outros objetos temporários.

import Foundation

class ImageCache {    private let cache = NSCache<NSString, UIImage>()        func getImage(forKey key: String) -> UIImage? {        return cache.object(forKey: key as NSString)    }        func setImage(_ image: UIImage, forKey key: String) {        cache.setObject(image, forKey: key as NSString)    }        func removeImage(forKey key: String) {        cache.removeObject(forKey: key as NSString)    }}

Vantagens:

• Não requer configuração — funciona "pronto para uso".
• Gerencia memória automaticamente (remove objetos em didReceiveMemoryWarning).
• Thread-safe.

Desvantagens:

• Os dados são perdidos ao reiniciar o aplicativo.
• Não é adequado para grandes volumes de dados (limitado pela RAM).

2. Core Data como cache persistente

Core Data é frequentemente usado não apenas como ORM, mas também como cache para dados estruturados. Isso é útil quando é necessário salvar objetos complexos com relacionamentos e realizar filtragens.

import CoreData

class CoreDataCache {    private let context: NSManagedObjectContext        init(context: NSManagedObjectContext) {        self.context = context    }        func cacheResponse(_ data: Data, forKey key: String) {        let cached = CachedResponse(context: context)        cached.key = key        cached.data = data        cached.timestamp = Date()        try? context.save()    }        func getCachedResponse(forKey key: String) -> Data? {        let fetchRequest: NSFetchRequest<CachedResponse> = CachedResponse.fetchRequest()        fetchRequest.predicate = NSPredicate(format: "key == %@", key)        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]        fetchRequest.fetchLimit = 1                guard let result = try? context.fetch(fetchRequest).first else { return nil }        return result.data    }}

Quando usar:

• Os dados devem ser preservados entre sessões.
• É necessária filtragem complexa (por exemplo, busca por texto).
• O volume de dados é moderado (até algumas centenas de milhares de registros).

3. Redis — cache no servidor para Swift

Redis é um armazenamento in-memory de alto desempenho que opera em rede. No contexto do Swift (iOS/macOS), o Redis é mais frequentemente usado no lado do servidor (Vapor, Kitura) para armazenar em cache sessões, resultados de consultas complexas e filas de tarefas. No entanto, existem bibliotecas cliente que permitem conectar-se ao Redis diretamente de um aplicativo móvel (por exemplo, via RediStack).

import RediStack

final class RedisCache {    private let connection: RedisConnection        init(host: String, port: Int = 6379) async throws {        self.connection = try await RedisConnection.connect(            to: .init(hostname: host, port: port)        )    }