Caching in Swift (iOS/macOS): Redis, NSCache und Core Data

Caching in Swift (iOS/macOS): Redis und Alternativen

Caching ist einer der wichtigsten Mechanismen zur Leistungsoptimierung mobiler und Desktop-Anwendungen in Swift. Es verkürzt die Datenladezeit, reduziert die Serverlast und verbessert die Benutzererfahrung. In diesem Artikel betrachten wir die wichtigsten Caching-Tools für iOS und macOS: von integrierten Lösungen (NSCache, URLCache) bis zur Integration mit externen Systemen (Redis) und persistenten Speichern (Core Data).

1. Integrierte Caching-Mechanismen

1.1 NSCache – schneller In-Memory-Cache

NSCache ist ein threadsicherer, automatisch bereinigbarer Cache, der sich ideal für die temporäre Speicherung von Objekten eignet, die wiederhergestellt werden können (z. B. Bilder oder Parsergebnisse).

import Foundation

let imageCache = NSCache<NSString, UIImage>()

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

    // Cache prüfen    if let cachedImage = imageCache.object(forKey: cacheKey) {        completion(cachedImage)        return    }

    // Daten laden    URLSession.shared.dataTask(with: url) { data, _, _ in        guard let data = data, let image = UIImage(data: data) else {            completion(nil)            return        }        // Im Cache speichern        imageCache.setObject(image, forKey: cacheKey)        completion(image)    }.resume()}

Besonderheiten:

• Entfernt Objekte automatisch bei Speicherknappheit (unterstützt countLimit und totalCostLimit).
• Ideal zum Caching geladener Bilder, JSON-API-Antworten.
• Speichert keine Daten zwischen App-Starts.

1.2 URLCache – systemweiter Cache für HTTP-Anfragen

URLCache bietet transparentes Caching von Netzwerkanfragen auf Systemebene. Unterstützt sowohl Festplatten- als auch Arbeitsspeicher-Speicherung.

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

// Beispiel einer Anfrage mit Cachinglet request = URLRequest(url: URL(string: "https://api.example.com/data")!,                         cachePolicy: .returnCacheDataElseLoad,                         timeoutInterval: 30)URLSession.shared.dataTask(with: request) { data, response, error in    // Daten werden automatisch zwischengespeichert}.resume()

Diese Methode eignet sich hervorragend für statische Ressourcen (Bilder, Konfigurationsdateien), ist jedoch nicht für dynamische Daten geeignet, die Aktualität erfordern.

2. Persistente Caching mit Core Data

Wenn Daten zwischen App-Sitzungen gespeichert werden müssen, verwenden Sie Core Data oder SQLite (über GRDB.swift). Nachfolgend ein Beispiel eines einfachen Caches mit Core Data:

import CoreData

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

    private init() {        // Core Data Stack einrichten (vereinfacht)        let container = NSPersistentContainer(name: "CacheModel")        container.loadPersistentStores { _, error in            if let error = error { fatalError("Core Data error: \\(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)