मोबाइल डेवलपमेंट में डेटा स्थायित्व — यह क्या है, तरीके और कैसे काम करता है

डेटा स्थायित्व क्या है

Data Persistence एप्लिकेशन की डिवाइस की नॉन-वॉलेटाइल मेमरी में डेटा सहेजने की क्षमता है। मोबाइल डेवलपमेंट में, पर्सिस्टेंस में डेटाबेस, फ़ाइल सिस्टम, सेटिंग्स और कैश शामिल हैं। प्रत्येक तन्त्र की प्रदर्शन, सुरक्षा और भंडारण क्षमता के मामले में अपनी विशेषताएँ हैं।

अस्थायी और स्थायी डेटा

अस्थायी डेटा केवल RAM में मौजूद होता है और प्रक्रिया समाप्त होने पर खो जाता है। इसमें स्क्रीन स्थिति, अस्थायी गणनाएँ और इमेज कैश शामिल हैं। स्थायी डेटा फ़ाइल सिस्टम या डेटाबेस में लिखा जाता है और एप्लिकेशन के पुनरारंभ के बाद भी उपलब्ध रहता है। इसमें उपयोगकर्ता सेटिंग्स, प्राधिकरण टोकन, संचालन इतिहास और डाउनलोड की गई सामग्री शामिल है।

स्टोरेज तन्त्र चुनने के मानदंड

स्टोरेज विधि चुनते समय, डेवलपर कई कारकों का मूल्यांकन करते हैं। डेटा प्रकार स्टोरेज संरचना निर्धारित करता है: सरल सेटिंग्स — SharedPreferences या DataStore, संरचित रिकॉर्ड — SQLite या Room, फ़ाइलें — File Storage। डेटा वॉल्यूम प्रदर्शन को प्रभावित करता है: डेटाबेस हजारों रिकॉर्ड के लिए ऑप्टिमाइज्ड हैं, जबकि फ़ाइलें बड़े बाइनरी ऑब्जेक्ट के लिए उपयुक्त हैं। सुरक्षा के लिए EncryptedSharedPreferences या SQLCipher के माध्यम से संवेदनशील जानकारी को एन्क्रिप्ट करने की आवश्यकता होती है।

data class StorageOption(
    name: String,
    dataType: StorageType,
    capacity: Long,
    secure: Boolean
)

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences और DataStore

SharedPreferences Android पर की-वैल्यू जोड़े संग्रहीत करने का क्लासिक तरीका है। यह API प्लेटफ़ॉर्म के शुरुआती संस्करणों से उपलब्ध है और प्राइमिटिव प्रकारों का समर्थन करती है: स्ट्रिंग्स, संख्याएँ और बूलियन मान। डेटा एप्लिकेशन की निजी निर्देशिका में XML फ़ाइल में संग्रहीत होता है और केवल इसकी प्रक्रिया के लिए ही सुलभ होता है।

वैकल्पिक के रूप में DataStore

Jetpack DataStore, Kotlin Coroutines और Flow पर निर्मित SharedPreferences का आधुनिक विकल्प है। DataStore दो विकल्प प्रदान करता है: सरल मानों के लिए Preferences DataStore और टाइपकृत ऑब्जेक्ट के लिए Proto DataStore। SharedPreferences के विपरीत, DataStore समवर्ती पहुंच के तहत डेटा संगति की गारंटी देता है और मुख्य थ्रेड को ब्लॉक किए बिना असांक्रनिक संचालनों का समर्थन करता है।

// SharedPreferences — पारंपरिक तरीका
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — असांक्रनिक दृष्टिकोण
val settingsDataStore = context
    .createDataStore("settings.pb")

val usernameFlow: Flow<String> = settingsDataStore
    .data
    .map { it[USERNAME_KEY] ?: "" }

iOS पर, SharedPreferences का समकक्ष UserDefaults है — Property List प्रारूप में सरल मानों को संग्रहीत करने की प्रणाली। UserDefaults सिंक्रनस पहुंच का उपयोग करता है और कम मात्रा में कॉन्फ़िगरेशन डेटा के लिए उपयुक्त है, लेकिन संवेदनशील जानकारी को संग्रहीत करने के लिए अनुशंसा नहीं है।

मोबाइल एप्स में SQLite

SQLite एक एम्बेडेड रिलेशनल डेटाबेस है जो अलग सर्वर के बिना एप्लिकेशन प्रक्रिया के अंदर चलती है। मोबाइल डेवलपमेंट में यह सबसे व्यापक DBMS है: यह दोनों प्लेटफ़ॉर्मों पर डिफ़ॉल्ट रूप से उपयोग की जाती है। Android SDK में SQLite शामिल करता है, और iOS इसे libsqlite3 लाइब्रेरी में शामिल करता है। SQLite मानक SQL, लेन-देन, इंडेक्स और ट्रिगर का समर्थन करती है।

टेबल बनाना और CRUD संचालन

SQLite के साथ काम डेटाबेस स्कीमा परिभाषित करने से शुरू होता है। डेवलपर टेबल, उनके फ़ील्ड और प्रकार परिभाषित करता है, फिर इंसर्ट, रीड, अपडेट और डिलीट संचालन करता है। Android पर SQLiteOpenHelper डेटाबेस निर्माण और माइग्रेशन का प्रबंधन करता है, जबकि iOS C इंटरफ़ेस या FMDB रैपर का उपयोग करता है।

// Android पर SQLiteOpenHelper
class DBHelper(context: Context) :
    SQLiteOpenHelper(context, "app.db", null, 1) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("""
            CREATE TABLE users (
                id INTEGER PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT UNIQUE
            )
        """)
    }

    fun insertUser(name: String, email: String) {
        val db = writableDatabase
        val values = ContentValues().apply {
            put("name", name)
            put("email", email)
        }
        db.insert("users", null, values)
    }
}

Room — Android के लिए ORM

Room Jetpack का एक लाइब्रेरी है जो SQLite के ऊपर ORM परत प्रदान करती है। Room SQL क्वेरी और ContentValues लिखने के दोहराउ काम को समाप्त करती है, उन्हें एनोटेशन्स और Kotlin फ़ंक्शन्स से बदलती है। Room कंपाइलर बिल्ड टाइम पर DAO (Data Access Object) कार्यान्वयन उत्पन्न करता है, जिससे SQL सिंटैक्स त्रुटियाँ समाप्त हो जाती हैं।

प्रोजेक्ट में Room सेट करना

Room को एकीकृत करने के लिए, आपको kapt निर्भरता जोड़नी होगी और एंटिटी क्लास, DAO इंटरफ़ेस और डेटाबेस क्लास को एनोटेट करना होगा। RoomDatabase प्रवेश बिंदु के रूप में कार्य करता है: इसके माध्यम से DAO प्राप्त किया जाता है और डेटाबेस संचालन किए जाते हैं। Room रिएक्टिव क्वेरी के लिए Flow, स्कीमा माइग्रेशन और कंपाइल-टाइम क्वेरी सत्यापन का समर्थन करता है।

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "full_name") val name: String,
    @ColumnInfo val email: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): Flow<List<User>>

    @Insert
    suspend fun insert(user: User)

    @Delete
    suspend fun delete(user: User)
}

@Database(
    entities = [User::class],
    version = 1
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Core Data — iOS फ़्रेमवर्क

Core Data ऑब्जेक्ट ग्राफ़ को प्रबंधित करने और इसे डिस्क पर संग्रहीत करने का Apple फ़्रेमवर्क है। Room के विपरीत, Core Data टेबल के साथ नहीं बल्कि प्रबंधित ऑब्जेक्ट (NSManagedObject) के साथ काम करता है जो संबंधों का अनुक्रम बनाते हैं। Core Data आलसी लोडिंग, बदलाव पूर्व की स्थिति में वापसी और NSFetchRequest के माध्यम से जटिल क्वेरी का समर्थन करता है।

Core Data स्टैक

Core Data का मूल तीन घटकों से मिलकर बनता है: प्रबंधित ऑब्जेक्ट कंटेक्स्ट (NSManagedObjectContext), पर्सिस्टेंट स्टोर कॉर्डिनेटर (NSPersistentStoreCoordinator) और डेटा मॉडल (NSManagedObjectModel)। NSPersistentContainer सभी घटकों को एक ही प्रवेश बिंदु में एकीकृत करता है, जो आधुनिक Swift एप्लिकेशन्स के लिए सेटअप को सरल बनाता है।

import CoreData

class PersistenceController {
    static let shared = PersistenceController()
    let container: NSPersistentContainer

    init() {
        container = NSPersistentContainer(name: "AppModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Failed: \(error)")
            }
        }
    }

    func saveUser(name: String, email: String) {
        let context = container.viewContext
        let user = User(context: context)
        user.name = name
        user.email = email

        do {
            try context.save()
        } catch let error {
            print("Save error: \(error)")
        }
    }
}

फ़ाइल स्टोरेज (File Storage) का उपयोग छवियों, वीडियो और दस्तावेज़ों को संग्रहीत करने के लिए किया जाता है। Android आंतरिक स्टोरेज (context.filesDir) — एप्लिकेशन के लिए निजी, और बाह्य स्टोरेज (Environment.getExternalStorageDirectory) — अन्य एप्लिकेशन्स के लिए सुलभ प्रदान करता है। iOS पर, फ़ाइलें Documents और Library निर्देशिकाओं में सहेजी जाती हैं, जहाँ Library/Caches कैश के लिए है जो iCloud में बैकअप नहीं होता। फ़ाइल संचालनों के लिए, दोनों प्लेटफ़ॉर्म File API और स्ट्रीमिंग रीड/राइट संचालन प्रदान करते हैं। Coil और SDWebImage जैसी आधुनिक लाइब्रेरी इष्टतम प्रदर्शन के लिए फ़ाइल स्टोरेज को RAM के साथ जोड़ते हुए कैशिंग परत जोड़ती हैं।

Android पर, जटिलता और कार्यक्षमता में Core Data का विकल्प Realm है, जो SQL परत के बिना सीधे मॉडल के साथ काम करने वाला ऑब्जेक्ट डेटाबेस है। Realm पढ़ने के संचालनों में SQLite से तेज़ है और लाइव ऑब्जेक्ट का समर्थन करता है जो डेटा बदलने पर UI को स्वचालित रूप से अपडेट करते हैं।