स्विफ्ट (iOS/macOS) में कैशिंग: Redis, NSCache और Core Data

स्विफ्ट (iOS/macOS) में कैशिंग: Redis और विकल्प

कैशिंग स्विफ्ट में मोबाइल और डेस्कटॉप एप्लिकेशन के प्रदर्शन को अनुकूलित करने के प्रमुख तंत्रों में से एक है। यह डेटा लोडिंग समय को कम करने, सर्वर पर लोड को कम करने और उपयोगकर्ता अनुभव को बेहतर बनाने में मदद करता है। इस लेख में, हम iOS और macOS के लिए मुख्य कैशिंग टूल्स पर चर्चा करेंगे: अंतर्निहित समाधान (NSCache, URLCache) से लेकर बाहरी सिस्टम (Redis) और स्थायी स्टोरेज (Core Data) के साथ एकीकरण तक।

1. अंतर्निहित कैशिंग तंत्र

1.1 NSCache — तेज़ इन-मेमोरी कैश

NSCache एक थ्रेड-सुरक्षित, स्वचालित रूप से साफ़ होने वाला कैश है, जो अस्थायी रूप से उन ऑब्जेक्ट्स को स्टोर करने के लिए आदर्श है जिन्हें पुनर्स्थापित किया जा सकता है (जैसे, इमेज या पार्सिंग परिणाम)।

import Foundation

let imageCache = NSCache<NSString, UIImage>()

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

    // कैश की जाँच करें    if let cachedImage = imageCache.object(forKey: cacheKey) {        completion(cachedImage)        return    }

    // डेटा लोड करें    URLSession.shared.dataTask(with: url) { data, _, _ in        guard let data = data, let image = UIImage(data: data) else {            completion(nil)            return        }        // कैश में सहेजें        imageCache.setObject(image, forKey: cacheKey)        completion(image)    }.resume()}

विशेषताएँ:

• मेमोरी की कमी होने पर स्वचालित रूप से ऑब्जेक्ट्स हटाता है (countLimit और totalCostLimit का समर्थन करता है)।
• लोड की गई इमेज, API JSON प्रतिक्रियाओं को कैश करने के लिए आदर्श।
• एप्लिकेशन के बीच डेटा सहेजता नहीं है।

1.2 URLCache — सिस्टम HTTP अनुरोध कैश

URLCache सिस्टम स्तर पर नेटवर्क अनुरोधों की पारदर्शी कैशिंग प्रदान करता है। डिस्क और रैम स्टोरेज का समर्थन करता है।

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

// कैशिंग के साथ अनुरोध का उदाहरणlet request = URLRequest(url: URL(string: "https://api.example.com/data")!,                         cachePolicy: .returnCacheDataElseLoad,                         timeoutInterval: 30)URLSession.shared.dataTask(with: request) { data, response, error in    // डेटा स्वचालित रूप से कैश हो जाएगा}.resume()

यह विधि स्थिर संसाधनों (इमेज, कॉन्फ़िगरेशन फ़ाइलें) के लिए बढ़िया काम करती है, लेकिन गतिशील डेटा के लिए उपयुक्त नहीं है जिसे अद्यतित रहने की आवश्यकता है।

2. Core Data के साथ स्थायी कैशिंग

यदि एप्लिकेशन सत्रों के बीच डेटा सहेजने की आवश्यकता है, तो Core Data या SQLite ( GRDB.swift के माध्यम से) का उपयोग करें। नीचे Core Data पर एक सरल कैश का उदाहरण दिया गया है:

import CoreData

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

    private init() {        // Core Data स्टैक सेटअप (सरलीकृत)        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)