Datalagring i mobilutveckling — vad det är, metoder och hur det fungerar

Vad är beständig datalagring

Data Persistence — applikationens förmåga att lagra data i enhetens icke-flyktiga minne. Inom mobilutveckling omfattar beständig lagring databaser, filsystem, inställningar och cache. Varje mekanism har sina egna prestanda-, säkerhets- och lagringsvolymegenskaper.

Tillfälliga och beständiga data

Tillfälliga data finns endast i RAM-minnet och förloras när processen avslutas. Detta inkluderar skärmtillstånd, tillfälliga beräkningar och bildcache. Beständiga data skrivs till filsystemet eller databasen och förblir tillgängliga efter omstart av applikationen. Detta inkluderar användarinställningar, auktoriseringstoken, operationshistorik och nedladdat innehåll.

Kriterier för val av lagringsmekanism

Vid val av lagringsmetod utvärderar utvecklaren flera faktorer. Datatypen bestämmer lagringsstrukturen: enkla inställningar — SharedPreferences eller DataStore, strukturerade poster — SQLite eller Room, filer — File Storage. Datavolymen påverkar prestanda: databaser är optimerade för tusentals poster och filer för stora binära objekt. Säkerhet kräver kryptering av känslig information via EncryptedSharedPreferences eller SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences och DataStore

SharedPreferences — det klassiska sättet att lagra nyckel-värdepar på Android. Detta API har funnits sedan plattformens första versioner och stöder primitiva typer: strängar, tal, booleska värden. Data lagras i en XML-fil i applikationens privata katalog och är endast tillgänglig för dess process.

DataStore som alternativ

Jetpack DataStore — den moderna ersättaren för SharedPreferences, byggd på Kotlin Coroutines och Flow. DataStore erbjuder två varianter: Preferences DataStore för enkla värden och Proto DataStore för typade objekt. Till skillnad från SharedPreferences garanterar DataStore datakonsekvens vid samtidig åtkomst och stöder asynkrona operationer utan att blockera huvudtråden.

// SharedPreferences — traditionellt sätt
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — asynkront tillvägagångssätt
val settingsDataStore = context
    .createDataStore("settings.pb")

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

På iOS är motsvarigheten till SharedPreferences UserDefaults — ett system för lagring av enkla värden i Property List-format. UserDefaults använder synkron åtkomst och är lämplig för små mängder konfigurationsdata men rekommenderas inte för lagring av känslig information.

SQLite i mobilappar

SQLite — en inbäddad relationsdatabas som körs inom applikationsprocessen utan separat server. Detta är den mest utbredda DBMS inom mobilutveckling: den används som standard på båda plattformarna. Android inkluderar SQLite i SDK och iOS i libsqlite3-biblioteket. SQLite stöder standard SQL, transaktioner, index och utlösare.

Skapa tabell och CRUD-operationer

Arbete med SQLite börjar med att skapa ett databasschema. Utvecklaren definierar tabeller, deras fält och typer, och utför sedan operationer för insättning, läsning, uppdatering och borttagning. SQLiteOpenHelper på Android hanterar skapande och migrering av databasen, medan C-gränssnittet eller FMDB-omslag används på iOS.

// SQLiteOpenHelper på Android
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 för Android

Room — bibliotek från Jetpack-sviten som tillhandahåller ett ORM-lager ovanpå SQLite. Room eliminerar rutinarbetet med att skriva SQL-frågor och ContentValues och ersätter dem med annoteringar och Kotlin-funktioner. Rooms kompilator genererar DAO-implementeringen (Data Access Object) under byggfasen, vilket eliminerar SQL-syntaxfel.

Konfigurera Room i projektet

För att ansluta Room måste man lägga till kapt-beroendet och annotera entitetsklassen, DAO-gränssnittet och databasklassen. RoomDatabase fungerar som en ingångspunkt: via den erhålls DAO och databasoperationer utförs. Room stöder Flow för reaktiva frågor, schemamigrering och frågevalidering vid kompilering.

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

Core Data — Apples ramverk för att hantera objektgrafer och spara dem på disk. Till skillnad från Room arbetar Core Data inte med tabeller utan med hanterade objekt (NSManagedObject) som bildar en relationshierarki. Core Data stöder lazy loading, ångra ändringar och komplexa frågor via NSFetchRequest.

Core Data-stack

Grunden för Core Data utgörs av en stack med tre komponenter: hanterad kontext (NSManagedObjectContext), beständigt lager (NSPersistentStoreCoordinator) och datamodell (NSManagedObjectModel). NSPersistentContainer förenar alla komponenter i en enda ingångspunkt, vilket förenklar konfigurationen för moderna Swift-applikationer.

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("Sparfel: \(error)")
        }
    }
}

Fillagring (File Storage) används för att spara bilder, videor och dokument. Android tillhandahåller intern lagring (context.filesDir) — privat för applikationen, och extern lagring (Environment.getExternalStorageDirectory) — tillgänglig för andra applikationer. På iOS sparas filer i katalogerna Documents och Library, där Library/Caches är avsedd för cache som inte säkerhetskopieras till iCloud. För att arbeta med filer tillhandahåller båda plattformarna File API och strömläsnings- och skrivoperationer. Moderna bibliotek som Coil och SDWebImage lägger till ett cachelager som kombinerar fillagring med RAM för optimal prestanda.

På Android är alternativet till Core Data när det gäller komplexitet och funktionalitet Realm — en objektorienterad databas som arbetar direkt med modeller utan SQL-lager. Realm är snabbare än SQLite vid läsoperationer och stöder live-objekt som automatiskt uppdaterar användargränssnittet när data ändras.