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

स्विफ्ट (iOS/macOS) में कैशिंग: in-memory से Redis तक

iOS और macOS के विकास में, कैशिंग एप्लिकेशन की गति बढ़ाने, सर्वर पर लोड कम करने और उपयोगकर्ता अनुभव को बेहतर बनाने के लिए एक महत्वपूर्ण उपकरण है। इस लेख में, हम स्विफ्ट में कैशिंग के मुख्य दृष्टिकोणों पर चर्चा करेंगे: सरल NSCache से लेकर Redis और SQLite पर आधारित पेशेवर समाधानों तक। प्रत्येक विधि का अपना उपयोग क्षेत्र है, और सही चुनाव डेटा के प्रकार, उसकी मात्रा और स्थायित्व आवश्यकताओं पर निर्भर करता है।

1. NSCache — अंतर्निहित in-memory कैशिंग

NSCache एक हल्का, थ्रेड-सुरक्षित कैश है जो Foundation में निर्मित है। यह संसाधनों की कमी होने पर स्वचालित रूप से मेमोरी मुक्त करता है, जो इसे इमेज, API डेटा और अन्य अस्थायी ऑब्जेक्ट्स को कैश करने के लिए आदर्श बनाता है।

import Foundation

class ImageCache {    private let cache = NSCache<NSString, UIImage>()        func getImage(forKey key: String) -> UIImage? {        return cache.object(forKey: key as NSString)    }        func setImage(_ image: UIImage, forKey key: String) {        cache.setObject(image, forKey: key as NSString)    }        func removeImage(forKey key: String) {        cache.removeObject(forKey: key as NSString)    }}

लाभ:

• कॉन्फ़िगरेशन की आवश्यकता नहीं — "बॉक्स से बाहर" काम करता है।
• स्वचालित रूप से मेमोरी प्रबंधित करता है (didReceiveMemoryWarning पर ऑब्जेक्ट्स हटाता है)।
• थ्रेड-सुरक्षित है।

कमियाँ:

• एप्लिकेशन पुनरारंभ होने पर डेटा खो जाता है।
• बड़ी मात्रा में डेटा के लिए उपयुक्त नहीं है (RAM द्वारा सीमित)।

2. Core Data एक स्थायी कैश के रूप में

Core Data का उपयोग अक्सर न केवल ORM के रूप में, बल्कि संरचित डेटा के लिए कैश के रूप में भी किया जाता है। यह तब सुविधाजनक होता है जब आपको संबंधों वाले जटिल ऑब्जेक्ट्स को सहेजने और फ़िल्टरिंग करने की आवश्यकता होती है।

import CoreData

class CoreDataCache {    private let context: NSManagedObjectContext        init(context: NSManagedObjectContext) {        self.context = context    }        func cacheResponse(_ data: Data, forKey key: String) {        let cached = CachedResponse(context: context)        cached.key = key        cached.data = data        cached.timestamp = Date()        try? context.save()    }        func getCachedResponse(forKey key: String) -> Data? {        let fetchRequest: NSFetchRequest<CachedResponse> = CachedResponse.fetchRequest()        fetchRequest.predicate = NSPredicate(format: "key == %@", key)        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "timestamp", ascending: false)]        fetchRequest.fetchLimit = 1                guard let result = try? context.fetch(fetchRequest).first else { return nil }        return result.data    }}

कब उपयोग करें:

• डेटा को सत्रों के बीच सहेजा जाना चाहिए।
• जटिल फ़िल्टरिंग की आवश्यकता है (जैसे, टेक्स्ट खोज)।
• डेटा की मात्रा मध्यम है (कुछ लाख रिकॉर्ड तक)।

3. Redis — स्विफ्ट के लिए सर्वर-साइड कैशिंग

Redis एक उच्च-प्रदर्शन in-memory स्टोर है जो नेटवर्क पर काम करता है। स्विफ्ट (iOS/macOS) के संदर्भ में, Redis का उपयोग अक्सर सर्वर साइड (Vapor, Kitura) पर सत्रों, जटिल क्वेरी परिणामों और कार्य कतारों को कैश करने के लिए किया जाता है। हालांकि, क्लाइंट लाइब्रेरीज़ मौजूद हैं जो मोबाइल एप्लिकेशन से सीधे Redis से कनेक्ट करने की अनुमति देती हैं (जैसे, RediStack के माध्यम से)।

import RediStack

final class RedisCache {    private let connection: RedisConnection        init(host: String, port: Int = 6379) async throws {        self.connection = try await RedisConnection.connect(            to: .init(hostname: host, port: port)        )    }