Adattárolás a mobilfejlesztésben — mi ez, módszerek és hogyan működik

Mi az állandó adattárolás

Data Persistence — az alkalmazás azon képessége, hogy adatokat tároljon az eszköz nem felejtő memóriájában. A mobilfejlesztésben az állandó tárolás magában foglalja az adatbázisokat, a fájlrendszert, a beállításokat és a gyorsítótárat. Minden mechanizmusnak megvannak a maga teljesítmény-, biztonsági és tárolási kapacitás jellemzői.

Ideiglenes és állandó adatok

Az ideiglenes adatok csak a RAM-ban léteznek, és a folyamat befejeződésekor elvesznek. Ide tartozik a képernyő állapota, az ideiglenes számítások és a képek gyorsítótára. Az állandó adatok a fájlrendszerbe vagy adatbázisba kerülnek, és az alkalmazás újraindítása után is elérhetőek maradnak. Ide tartoznak a felhasználói beállítások, hitelesítési tokenek, művelettörténet és letöltött tartalmak.

A tárolási mechanizmus kiválasztásának szempontjai

A tárolási mód kiválasztásakor a fejlesztő több tényezőt is értékel. Az adatok típusa határozza meg a tárolás szerkezetét: egyszerű beállítások — SharedPreferences vagy DataStore, strukturált rekordok — SQLite vagy Room, fájlok — File Storage. Az adatok mennyisége befolyásolja a teljesítményt: az adatbázisok több ezer rekordra optimalizáltak, a fájlok pedig nagy bináris objektumokra. A biztonság az érzékeny információk titkosítását igényli EncryptedSharedPreferences vagy SQLCipher segítségével.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences és DataStore

SharedPreferences — a kulcs-érték párok tárolásának klasszikus módja Androidon. Ez az API a platform első verziói óta létezik, és támogatja a primitív típusokat: karakterláncok, számok, logikai értékek. Az adatok XML fájlban tárolódnak az alkalmazás privát könyvtárában, és csak a folyamata számára elérhetőek.

A DataStore mint alternatíva

A Jetpack DataStore — a SharedPreferences modern helyettesítője, amely Kotlin Coroutines és Flow alapokra épül. A DataStore két változatot kínál: Preferences DataStore egyszerű értékekhez és Proto DataStore típusos objektumokhoz. A SharedPreferences-szel ellentétben a DataStore garantálja az adatok konzisztenciáját egyidejű hozzáférés esetén, és támogatja az aszinkron műveleteket a fő szál blokkolása nélkül.

// SharedPreferences — hagyományos mód
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — aszinkron megközelítés
val settingsDataStore = context
    .createDataStore("settings.pb")

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

iOS rendszeren a SharedPreferences megfelelője a UserDefaults — egyszerű értékek tárolására szolgáló rendszer Property List formátumban. A UserDefaults szinkron hozzáférést használ, és kis mennyiségű konfigurációs adat tárolására alkalmas, de érzékeny információk tárolására nem ajánlott.

SQLite mobilalkalmazásokban

SQLite — beágyazott relációs adatbázis, amely az alkalmazás folyamatán belül működik külön szerver nélkül. Ez a legelterjedtebb DBMS a mobilfejlesztésben: alapértelmezetten mindkét platformon használják. Az Android tartalmazza az SQLite-ot az SDK-ban, az iOS pedig a libsqlite3 könyvtárban. Az SQLite támogatja a szabvány SQL-t, tranzakciókat, indexeket és triggereket.

Tábla létrehozása és CRUD műveletek

Az SQLite-tal való munka az adatbázisséma létrehozásával kezdődik. A fejlesztő meghatározza a táblákat, azok mezőit és típusait, majd beszúrási, olvasási, frissítési és törlési műveleteket hajt végre. Az SQLiteOpenHelper Androidon kezeli az adatbázis létrehozását és migrációját, iOS-en pedig a C interfész vagy az FMDB burkoló használatos.

// SQLiteOpenHelper Androidon
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 — ORM Androidhoz

Room — könyvtár a Jetpack csomagból, amely ORM réteget biztosít az SQLite felett. A Room kiküszöböli az SQL-lekérdezések és ContentValues írásának rutinmunkáját, helyette annotációkat és Kotlin függvényeket használ. A Room fordítója a build során generálja a DAO (Data Access Object) implementációt, ami kiküszöböli az SQL szintaxis hibákat.

A Room beállítása a projektben

A Room csatlakoztatásához hozzá kell adni a kapt függőséget, és annotálni kell az entitás osztályt, a DAO interfészt és az adatbázis osztályt. A RoomDatabase belépési pontként szolgál: rajta keresztül érhető el a DAO és hajthatók végre az adatbázis műveletek. A Room támogatja a Flow-t reaktív lekérdezésekhez, a séma migrációt és a lekérdezések fordítási idejű ellenőrzését.

@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 keretrendszer

Core Data — Apple keretrendszer objektumgráfok kezelésére és azok lemezre mentésére. A Room-tól eltérően a Core Data nem táblákkal dolgozik, hanem felügyelt objektumokkal (NSManagedObject), amelyek kapcsolati hierarchiát alkotnak. A Core Data támogatja a lusta betöltést, a módosítások visszavonását és az összetett lekérdezéseket NSFetchRequest segítségével.

Core Data Stack

A Core Data alapját három komponensből álló verem képezi: felügyelt kontextus (NSManagedObjectContext), állandó tároló (NSPersistentStoreCoordinator) és adatmodell (NSManagedObjectModel). Az NSPersistentContainer egyetlen belépési pontba egyesíti az összes komponenst, leegyszerűsítve a konfigurációt a modern Swift alkalmazások számára.

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("Mentési hiba: \(error)")
        }
    }
}

A fájltárolást (File Storage) képek, videók és dokumentumok mentésére használják. Az Android belső tárolót (context.filesDir) — az alkalmazás számára privát, és külső tárolót (Environment.getExternalStorageDirectory) — más alkalmazások számára elérhető, biztosít. iOS-en a fájlok a Documents és Library könyvtárakba kerülnek, a Library/Caches pedig az iCloudba nem mentett gyorsítótár számára van fenntartva. A fájlokkal való munkához mindkét platform File API-t és adatfolyam olvasási/írási műveleteket biztosít. A modern könyvtárak, mint a Coil és az SDWebImage, gyorsítótárazási réteget adnak hozzá, amely a fájltárolást RAM-mal kombinálja az optimális teljesítmény érdekében.

Androidon a Core Data alternatívája összetettség és funkcionalitás tekintetében a Realm — egy objektumorientált adatbázis, amely közvetlenül a modellekkel dolgozik SQL réteg nélkül. A Realm gyorsabb az SQLite-nál az olvasási műveletekben, és támogatja az élő objektumokat, amelyek automatikusan frissítik a UI-t az adatok változásakor.