Caching in Swift (iOS/macOS): Redis, NSCache und andere Lösungen

Caching in Swift (iOS/macOS): Redis und andere Werkzeuge

Caching ist eine der wichtigsten Strategien zur Leistungsoptimierung mobiler und Desktop-Anwendungen in Swift. Es verkürzt die Ladezeiten von Daten, reduziert die Netzwerk- und Serverlast und ermöglicht den Offline-Betrieb der Anwendung. Im Apple-Ökosystem stehen sowohl integrierte Mechanismen (NSCache, URLCache) als auch Drittanbieter-Lösungen, einschließlich der Integration mit Redis, zur Verfügung. In diesem Artikel werden wir die wichtigsten Caching-Werkzeuge für iOS und macOS mit Codebeispielen im Detail besprechen.

1. Integrierte Caching-Mechanismen in Foundation

NSCache – leichtgewichtiger Cache im Arbeitsspeicher

NSCache ist ein threadsicherer, automatisch verwalteter Cache, der Objekte bei Speicherknappheit entfernt. Ideal geeignet für die temporäre Speicherung von Bildern, Modelldaten oder Berechnungsergebnissen.

import Foundation

let imageCache = NSCache<NSString, UIImage>()

// Grenzen festlegenimageCache.countLimit = 100    // Maximal 100 ObjekteimageCache.totalCostLimit = 50 * 1024 * 1024 // 50 MB

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

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

Vorteile: Einfachheit, automatische Bereinigung, Unterstützung der Objektkosten.

Nachteile: Nur Cache im Arbeitsspeicher, keine Persistenz.

URLCache – Caching von HTTP-Anfragen

URLCache speichert Antworten von URLSession automatisch zwischen. Es arbeitet sowohl im Arbeitsspeicher als auch auf der Festplatte. Es kann global oder für eine bestimmte Sitzung konfiguriert werden.

import Foundation

// Cache-Konfiguration: 50 MB im Arbeitsspeicher und 100 MB auf der Festplattelet cache = URLCache(memoryCapacity: 50 * 1024 * 1024,                     diskCapacity: 100 * 1024 * 1024,                     diskPath: "myCache")URLCache.shared = cache

// Verwendung mit 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    // Daten werden automatisch zwischengespeichert}task.resume()

Die Verwaltung der Caching-Richtlinie erfolgt über Cache-Control-Header des Servers oder requestCachePolicy.

2. Datei-Caching für den Offline-Zugriff

Wenn Daten zwischen verschiedenen App-Starts erhalten bleiben sollen, wird das Datei-Caching im Verzeichnis Caches verwendet. Praktisch für JSON, Bilder oder serialisierte Objekte.

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 – verteiltes Caching für den Serverteil