Caching in Swift: Redis, Memcached und integrierte Lösungen von A bis Z

Caching in Swift: Redis, Memcached und integrierte Lösungen: von A bis Z

Caching ist eine der wichtigsten Strategien zur Leistungsoptimierung in iOS- und macOS-Anwendungen. In diesem Artikel gehen wir im Detail darauf ein, wie man Caching in Swift organisiert: vom integrierten NSCache bis zur Arbeit mit externen Systemen wie Redis und Memcached. Sie erfahren, wann Sie welches Werkzeug wählen sollten, und erhalten fertige Codebeispiele für jeden Ansatz.

Warum ist Caching in Swift-Anwendungen notwendig?

Jede Anwendung, die mit Netzwerkanfragen, Datenbanken oder rechenintensiven Aufgaben arbeitet, kann vom Caching profitieren. Die wichtigsten Vorteile:

• Geschwindigkeit: Daten aus dem Cache werden in Millisekunden zurückgegeben, ohne Verzögerungen durch Netzwerk oder Festplatte.
• Datensparsamkeit: Weniger Anfragen an den Server – geringere Kosten für Benutzer und Server.
• Offline-Zugriff: Bei richtiger Implementierung funktioniert ein Teil der Funktionalität ohne Internet.
• Reduzierte Serverlast: Besonders relevant für serverseitige Swift-Lösungen (Vapor, Kitura).

Integrierte Lösungen: NSCache und URLCache

NSCache – leichtgewichtiges Caching im Arbeitsspeicher

NSCache ist eine in Foundation integrierte Klasse zur temporären Speicherung von Schlüssel-Wert-Paaren. Sie entfernt Objekte automatisch bei Speicherknappheit, was sie ideal zum Caching von Bildern, JSON-Antworten und anderen unkritischen Daten macht.

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()    }}

// Verwendunglet cache = ImageCacheManager.sharedcache.setImageData(imageData, forKey: "avatar_123")if let cachedData = cache.getImageData(forKey: "avatar_123") {    print("Daten aus dem Cache: \\(cachedData.count) Bytes")}

Besonderheiten:

• Automatische Speicherverwaltung – keine manuelle Löschung von Objekten erforderlich.
• Thread-sicher – kann aus verschiedenen Threads verwendet werden.
• Keine Garantie für Datenbeständigkeit – der Cache kann vom System geleert werden.

URLCache – Caching von HTTP-Anfragen

URLCache ermöglicht Caching auf der Ebene von Netzwerkanfragen. Es arbeitet mit URLSession zusammen und speichert Serverantworten automatisch.

import Foundation

// Cache-Konfigurationlet memoryCapacity = 50 * 1024 * 1024 // 50 MBlet diskCapacity = 100 * 1024 * 1024 // 100 MBlet urlCache = URLCache(memoryCapacity: memoryCapacity,                         diskCapacity: diskCapacity,                         diskPath: "myCache")

URLCache.shared = urlCache

// Session-Konfigurationlet config = URLSessionConfiguration.defaultconfig.requestCachePolicy = .returnCacheDataElseLoadconfig.urlCache = urlCache

let session = URLSession(configuration: config)

// Ausführen der Anfragelet url = URL(string: "https://api.example.com/data")!let task = session.dataTask(with: url) { data, response, error in    if let data = data {        print("Erhalten \\(data.count) Bytes")        // Daten werden automatisch zwischengespeichert    }}task.resume()

Für eine feinere Caching-Steuerung verwenden Sie HTTP-Header und Cache-Control-Richtlinien auf der Serverseite.

Redis in Swift: Server-seitiges Caching

Redis ist ein leistungsstarker In-Memory-Schlüssel-Wert-Speicher. Für Swift-Entwickler, die mit serverseitigen Frameworks (Vapor, Perfect) arbeiten, ist Redis die Standardwahl für Caching.