Mise en cache en Swift (iOS/macOS) : Redis, NSCache et autres solutions

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

La mise en cache est l'une des stratégies 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 réseau et les serveurs, et d'assurer le fonctionnement de l'application en mode hors ligne. Dans l'écosystème Apple, des mécanismes intégrés (NSCache, URLCache) ainsi que des solutions tierces, y compris l'intégration avec Redis, sont disponibles. Dans cet article, nous analyserons en détail les principaux outils de mise en cache pour iOS et macOS avec des exemples de code.

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

NSCache — cache léger en mémoire

NSCache est un cache thread-safe et géré automatiquement qui supprime les objets en cas de manque de mémoire. Idéal pour le stockage temporaire d'images, de données de modèles ou de résultats de calculs.

import Foundation

let imageCache = NSCache<NSString, UIImage>()

// Définition des limitesimageCache.countLimit = 100    // Maximum 100 objetsimageCache.totalCostLimit = 50 * 1024 * 1024 // 50 MB

// Sauvegardefunc cacheImage(_ image: UIImage, forKey key: String) {    imageCache.setObject(image, forKey: key as NSString, cost: image.size.width * image.size.height * 4)}

// Récupérationfunc getCachedImage(forKey key: String) -> UIImage? {    return imageCache.object(forKey: key as NSString)}

Avantages : simplicité, nettoyage automatique, prise en charge du coût des objets.

Inconvénients : cache uniquement en mémoire, pas de persistance.

URLCache — mise en cache des requêtes HTTP

URLCache met automatiquement en cache les réponses de URLSession. Fonctionne à la fois en mémoire et sur disque. Se configure globalement ou pour une session spécifique.

import Foundation

// Configuration du cache : 50 MB en mémoire et 100 MB sur disquelet cache = URLCache(memoryCapacity: 50 * 1024 * 1024,                     diskCapacity: 100 * 1024 * 1024,                     diskPath: "myCache")URLCache.shared = cache

// Utilisation avec URLSessionlet config = URLSessionConfiguration.defaultconfig.urlCache = cacheconfig.requestCachePolicy = .returnCacheDataElseLoadlet session = URLSession(configuration: config)

let request = URLRequest(url: URL(string: "https://api.example.com/data")!)let task = session.dataTask(with: request) { data, response, error in    // Les données seront automatiquement mises en cache}task.resume()

La gestion de la politique de mise en cache se fait via les en-têtes Cache-Control du serveur ou requestCachePolicy.

2. Mise en cache de fichiers pour l'accès hors ligne

Lorsqu'il est nécessaire de conserver des données entre les lancements de l'application, la mise en cache de fichiers dans le répertoire Caches est utilisée. Pratique pour le JSON, les images ou les objets sérialisés.

import Foundation

class FileCache {    private let fileManager = FileManager.default    private lazy var cacheDirectory: URL = {        let paths = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)        return paths[0].appendingPathComponent("DataCache", isDirectory: true)    }()        init() {        try? fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true)    }        func save(data: Data, forKey key: String) {        let fileURL = cacheDirectory.appendingPathComponent(key)        try? data.write(to: fileURL)    }        func load(forKey key: String) -> Data? {        let fileURL = cacheDirectory.appendingPathComponent(key)        return try? Data(contentsOf: fileURL)    }        func clearAll() {        try? fileManager.removeItem(at: cacheDirectory)        try? fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true)    }}

3. Redis — mise en cache distribuée pour la partie serveur