Mise en cache en Swift : Redis, Memcached et solutions intégrées de A à Z

Mise en cache en Swift : Redis, Memcached et solutions intégrées : de A à Z

La mise en cache est l'une des stratégies clés d'optimisation des performances dans les applications iOS et macOS. Dans cet article, nous allons détailler comment organiser la mise en cache en Swift : du NSCache intégré au travail avec des systèmes externes comme Redis et Memcached. Vous apprendrez quel outil choisir selon le cas, et obtiendrez des exemples de code prêts à l'emploi pour chaque approche.

Pourquoi la mise en cache dans les applications Swift ?

Toute application qui travaille avec des requêtes réseau, des bases de données ou des calculs lourds peut bénéficier de la mise en cache. Les principaux avantages :

• Vitesse : les données du cache sont renvoyées en millisecondes, sans délai réseau ou disque.
• Économie de trafic : moins de requêtes au serveur = moins de coûts pour l'utilisateur et le serveur.
• Accès hors ligne : avec une bonne implémentation, une partie des fonctionnalités fonctionne sans Internet.
• Réduction de la charge serveur : particulièrement pertinent pour les solutions Swift côté serveur (Vapor, Kitura).

Solutions intégrées : NSCache et URLCache

NSCache — mise en cache légère en mémoire

NSCache est une classe intégrée à Foundation pour le stockage temporaire de paires clé-valeur. Elle supprime automatiquement les objets en cas de manque de mémoire, ce qui la rend idéale pour la mise en cache d'images, de réponses JSON et d'autres données non critiques.

import Foundation

class ImageCacheManager {    static let shared = ImageCacheManager()    private let cache = NSCache<NSString, NSData>()        func setImageData(_ data: Data, forKey key: String) {        cache.setObject(data as NSData, forKey: key as NSString)    }        func getImageData(forKey key: String) -> Data? {        return cache.object(forKey: key as NSString) as Data?    }        func removeAll() {        cache.removeAllObjects()    }}

// Utilisationlet cache = ImageCacheManager.sharedcache.setImageData(imageData, forKey: "avatar_123")if let cachedData = cache.getImageData(forKey: "avatar_123") {    print("Données du cache : \\(cachedData.count) octets")}

Caractéristiques :

• Gestion automatique de la mémoire — pas besoin de supprimer manuellement les objets.
• Thread-safe — peut être utilisé depuis différents threads.
• Ne garantit pas la persistance des données — le cache peut être vidé par le système.

URLCache — mise en cache des requêtes HTTP

URLCache assure la mise en cache au niveau des requêtes réseau. Il fonctionne avec URLSession et sauvegarde automatiquement les réponses du serveur.

import Foundation

// Configuration du cachelet memoryCapacity = 50 * 1024 * 1024 // 50 Molet diskCapacity = 100 * 1024 * 1024 // 100 Molet urlCache = URLCache(memoryCapacity: memoryCapacity,                         diskCapacity: diskCapacity,                         diskPath: "myCache")

URLCache.shared = urlCache

// Configuration de la sessionlet config = URLSessionConfiguration.defaultconfig.requestCachePolicy = .returnCacheDataElseLoadconfig.urlCache = urlCache

let session = URLSession(configuration: config)

// Exécution de la requêtelet url = URL(string: "https://api.example.com/data")!let task = session.dataTask(with: url) { data, response, error in    if let data = data {        print("Reçu \\(data.count) octets")        // Les données sont automatiquement mises en cache    }}task.resume()

Pour un réglage fin de la mise en cache, utilisez les en-têtes HTTP et les politiques Cache-Control côté serveur.

Redis en Swift : mise en cache côté serveur

Redis est un stockage clé-valeur en mémoire haute performance. Pour les développeurs Swift travaillant avec des frameworks serveur (Vapor, Perfect), Redis est le choix standard pour la mise en cache