Mise en cache en Swift (iOS/macOS) : Redis, NSCache et Core Data

Mise en cache en Swift (iOS/macOS) : Redis et alternatives

La mise en cache est l'un des mécanismes clés pour optimiser les performances des applications mobiles et de bureau en Swift. Elle permet de réduire le temps de chargement des données, de diminuer la charge sur le serveur et d'améliorer l'expérience utilisateur. Dans cet article, nous examinerons les principaux outils de mise en cache pour iOS et macOS : des solutions intégrées (NSCache, URLCache) à l'intégration avec des systèmes externes (Redis) et des stockages persistants (Core Data).

1. Mécanismes de mise en cache intégrés

1.1 NSCache — cache rapide en mémoire

NSCache est un cache thread-safe et auto-nettoyant, idéal pour le stockage temporaire d'objets qui peuvent être recréés (par exemple, des images ou des résultats d'analyse).

import Foundation

let imageCache = NSCache<NSString, UIImage>()

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

    // Vérifier le cache    if let cachedImage = imageCache.object(forKey: cacheKey) {        completion(cachedImage)        return    }

    // Charger les données    URLSession.shared.dataTask(with: url) { data, _, _ in        guard let data = data, let image = UIImage(data: data) else {            completion(nil)            return        }        // Sauvegarder dans le cache        imageCache.setObject(image, forKey: cacheKey)        completion(image)    }.resume()}

Caractéristiques :

• Supprime automatiquement les objets en cas de manque de mémoire (prend en charge countLimit et totalCostLimit).
• Idéal pour la mise en cache des images téléchargées, des réponses JSON d'API.
• Ne conserve pas les données entre les lancements de l'application.

1.2 URLCache — cache système des requêtes HTTP

URLCache fournit une mise en cache transparente des requêtes réseau au niveau du système. Prend en charge le stockage sur disque et en mémoire.

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

// Exemple de requête avec mise en cachelet request = URLRequest(url: URL(string: "https://api.example.com/data")!,                         cachePolicy: .returnCacheDataElseLoad,                         timeoutInterval: 30)URLSession.shared.dataTask(with: request) { data, response, error in    // Les données seront automatiquement mises en cache}.resume()

Cette méthode fonctionne parfaitement pour les ressources statiques (images, fichiers de configuration), mais ne convient pas aux données dynamiques nécessitant une actualisation.

2. Mise en cache persistante avec Core Data

Si vous devez conserver des données entre les sessions de l'application, utilisez Core Data ou SQLite (via GRDB.swift). Voici un exemple de cache simple avec Core Data :

import CoreData

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

    private init() {        // Configuration de la pile Core Data (simplifiée)        let container = NSPersistentContainer(name: "CacheModel")        container.loadPersistentStores { _, error in            if let error = error { fatalError("Erreur 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)