Cache em Swift: Redis, Memcached e soluções nativas para iOS/macOS

Introdução: Por que o cache é necessário em aplicações Swift?

Aplicações modernas para iOS e macOS trabalham com grandes volumes de dados: imagens, respostas JSON de APIs, resultados de cálculos. Sem cache, cada acesso aos dados resulta em recarregamento ou recálculo, o que impacta negativamente o desempenho, o consumo de tráfego e o tempo de resposta. Cache em Swift é uma estratégia de armazenamento temporário de dados frequentemente usados em um armazenamento rápido (memória RAM ou disco local) para acelerar o acesso.

Neste artigo, vamos explorar três abordagens principais para cache no ecossistema Swift:

• Soluções nativas: NSCache e URLCache — ferramentas leves e eficientes para a maioria das tarefas.
• Redis — um poderoso cache de servidor para sistemas distribuídos.
• Memcached — um sistema de cache em memória de alto desempenho.

Você aprenderá como integrar cada uma dessas ferramentas em um projeto Swift, verá exemplos de código e entenderá qual opção escolher para uma tarefa específica.

Soluções nativas: NSCache e URLCache

A Apple fornece dois mecanismos de cache nativos poderosos que não requerem a instalação de bibliotecas de terceiros. Eles são ideais para 90% das tarefas no desenvolvimento mobile.

NSCache — cache em memória

NSCache é um dicionário thread-safe com gerenciamento automático de memória. Ele remove automaticamente objetos quando há falta de memória RAM, tornando-o ideal para armazenar em cache imagens, modelos de dados e quaisquer objetos pesados.

import Foundation

// Criando um cache para UIImage
let imageCache = NSCache<NSString, UIImage>()

// Função para carregar imagem com cache
func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
    // Verifica o cache
    if let cachedImage = imageCache.object(forKey: url.absoluteString as NSString) {
        completion(cachedImage)
        return
    }
    
    // Carrega os dados
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data, let image = UIImage(data: data) else {
            completion(nil)
            return
        }
        // Salva no cache
        imageCache.setObject(image, forKey: url.absoluteString as NSString)
        completion(image)
    }.resume()
}

Vantagens do NSCache:

• Limpeza automática em caso de memory warning
• Thread-safe sem bloqueios adicionais
• Possibilidade de definir limite de quantidade de objetos e custo total

URLCache — cache de respostas HTTP

URLCache é um cache de sistema para requisições HTTP. Ele salva as respostas do servidor em disco e memória, gerenciando automaticamente seu tempo de vida com base nos cabeçalhos HTTP (Cache-Control, Expires).

import Foundation

// Configuração do URLCache (geralmente no AppDelegate ou SceneDelegate)
let cacheSize = 50 * 1024 * 1024 // 50 MB
let urlCache = URLCache(memoryCapacity: cacheSize, diskCapacity: cacheSize, diskPath: "myCache")
URLCache.shared = urlCache

// Exemplo de requisição com cache
let request = URLRequest(url: URL(string: "https://api.example.com/data")!)
URLSession.shared.dataTask(with: request) { data, response, error in
    // URLCache lida automaticamente com o cache
    // com base nos cabeçalhos Cache-Control
}.resume()

Quando usar URLCache:

• Para armazenar em cache respostas de REST API
• Para recursos estáticos (imagens, arquivos de configuração)
• Quando é necessário respeitar a política de cache do servidor

Redis — cache distribuído para o lado do servidor Swift

Redis é um armazenamento de dados em memória de alto desempenho, frequentemente usado como servidor de cache. Para Swift, existem vários clientes, o mais popular