Caché en Swift (iOS/macOS): Redis, NSCache y Core Data

Caché en Swift (iOS/macOS): Redis y alternativas

El caché es uno de los mecanismos clave para optimizar el rendimiento de aplicaciones móviles y de escritorio en Swift. Permite reducir el tiempo de carga de datos, disminuir la carga en el servidor y mejorar la experiencia del usuario. En este artículo, analizaremos las principales herramientas de caché para iOS y macOS: desde soluciones integradas (NSCache, URLCache) hasta la integración con sistemas externos (Redis) y almacenes persistentes (Core Data).

1. Mecanismos de caché integrados

1.1 NSCache — caché rápida en memoria

NSCache es un caché seguro para subprocesos y de limpieza automática, ideal para almacenar temporalmente objetos que se pueden regenerar (por ejemplo, imágenes o resultados de análisis).

import Foundation

let imageCache = NSCache<NSString, UIImage>()

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

    // Verificamos el caché    if let cachedImage = imageCache.object(forKey: cacheKey) {        completion(cachedImage)        return    }

    // Cargamos los datos    URLSession.shared.dataTask(with: url) { data, _, _ in        guard let data = data, let image = UIImage(data: data) else {            completion(nil)            return        }        // Guardamos en el caché        imageCache.setObject(image, forKey: cacheKey)        completion(image)    }.resume()}

Características:

• Elimina automáticamente objetos cuando hay poca memoria (admite countLimit y totalCostLimit).
• Ideal para almacenar en caché imágenes descargadas, respuestas JSON de API.
• No conserva datos entre ejecuciones de la aplicación.

1.2 URLCache — caché del sistema para solicitudes HTTP

URLCache proporciona un caché transparente de solicitudes de red a nivel del sistema. Admite almacenamiento en disco y en memoria.

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

// Ejemplo de solicitud con cachélet request = URLRequest(url: URL(string: "https://api.example.com/data")!,                         cachePolicy: .returnCacheDataElseLoad,                         timeoutInterval: 30)URLSession.shared.dataTask(with: request) { data, response, error in    // Los datos se almacenarán en caché automáticamente}.resume()

Este método funciona muy bien para recursos estáticos (imágenes, archivos de configuración), pero no es adecuado para datos dinámicos que requieren actualización constante.

2. Caché persistente con Core Data

Si necesita conservar datos entre sesiones de la aplicación, use Core Data o SQLite (a través de GRDB.swift). A continuación, un ejemplo de un caché simple con Core Data:

import CoreData

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

    private init() {        // Configuración del stack de Core Data (simplificado)        let container = NSPersistentContainer(name: "CacheModel")        container.loadPersistentStores { _, error in            if let error = error { fatalError("Error de 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)