Gegevensopslag in mobiele ontwikkeling — wat is het, methoden en hoe het werkt

Wat is permanente gegevensopslag

Data Persistence — het vermogen van een app om gegevens op te slaan in het niet-vluchtige geheugen van het apparaat. In mobiele ontwikkeling omvat permanente opslag databases, bestandssysteem, instellingen en cache. Elk mechanisme heeft zijn eigen prestatie-, beveiligings- en opslagvolume-eigenschappen.

Tijdelijke en permanente gegevens

Tijdelijke gegevens bestaan alleen in het RAM-geheugen en gaan verloren wanneer het proces wordt beëindigd. Hiertoe behoren schermstatus, tijdelijke berekeningen en afbeeldingscache. Permanente gegevens worden naar het bestandssysteem of de database geschreven en blijven toegankelijk na het opnieuw opstarten van de app. Hiertoe behoren gebruikersinstellingen, autorisatietokens, bewerkingsgeschiedenis en gedownloade inhoud.

Criteria voor het kiezen van een opslagmechanisme

Bij het kiezen van een opslagmethode evalueert de ontwikkelaar verschillende factoren. Het gegevenstype bepaalt de opslagstructuur: eenvoudige instellingen — SharedPreferences of DataStore, gestructureerde records — SQLite of Room, bestanden — File Storage. De hoeveelheid gegevens beïnvloedt de prestaties: databases zijn geoptimaliseerd voor duizenden records en bestanden voor grote binaire objecten. Beveiliging vereist versleuteling van gevoelige informatie via EncryptedSharedPreferences of SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences en DataStore

SharedPreferences — de klassieke manier om sleutel-waardeparen op te slaan op Android. Deze API bestaat sinds de eerste versies van het platform en ondersteunt primitieve typen: strings, getallen, booleaanse waarden. Gegevens worden opgeslagen in een XML-bestand in de privémap van de app en zijn alleen toegankelijk voor het eigen proces.

DataStore als alternatief

Jetpack DataStore — de moderne vervanger van SharedPreferences, gebouwd op Kotlin Coroutines en Flow. DataStore biedt twee varianten: Preferences DataStore voor eenvoudige waarden en Proto DataStore voor getypeerde objecten. In tegenstelling tot SharedPreferences garandeert DataStore gegevensconsistentie bij gelijktijdige toegang en ondersteunt het asynchrone bewerkingen zonder de hoofdthread te blokkeren.

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

// DataStore — asynchrone benadering
val settingsDataStore = context
    .createDataStore("settings.pb")

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

Op iOS is het equivalent van SharedPreferences UserDefaults — een systeem voor het opslaan van eenvoudige waarden in Property List-formaat. UserDefaults gebruikt synchrone toegang en is geschikt voor kleine hoeveelheden configuratiegegevens, maar wordt niet aanbevolen voor het opslaan van gevoelige informatie.

SQLite in mobiele apps

SQLite — een ingebedde relationele database die binnen het app-proces werkt zonder aparte server. Dit is de meest voorkomende DBMS in mobiele ontwikkeling: het wordt standaard op beide platforms gebruikt. Android bevat SQLite in de SDK en iOS in de libsqlite3-bibliotheek. SQLite ondersteunt standaard SQL, transacties, indexen en triggers.

Tabel maken en CRUD-bewerkingen

Werken met SQLite begint met het maken van een databaseschema. De ontwikkelaar definieert tabellen, hun velden en typen, en voert vervolgens bewerkingen uit voor toevoegen, lezen, bijwerken en verwijderen. SQLiteOpenHelper op Android beheert het maken en migreren van de database, terwijl op iOS de C-interface of FMDB-wrapper wordt gebruikt.

// SQLiteOpenHelper op 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 voor Android

Room — bibliotheek uit de Jetpack-suite, die een ORM-laag boven SQLite biedt. Room elimineert het routinematige schrijven van SQL-query's en ContentValues en vervangt ze door annotaties en Kotlin-functies. De Room-compiler genereert de DAO-implementatie (Data Access Object) tijdens de build, waardoor fouten in SQL-syntaxis worden voorkomen.

Room configureren in een project

Om Room aan te sluiten, moet de kapt-afhankelijkheid worden toegevoegd en de entiteitsklasse, DAO-interface en databaseklasse worden geannoteerd. RoomDatabase dient als ingangspunt: via deze wordt DAO verkregen en worden bewerkingen op de database uitgevoerd. Room ondersteunt Flow voor reactieve query's, schemamigratie en query-validatie tijdens compilatie.

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

Core Data — Apple-framework voor het beheren van een objectgraaf en het opslaan ervan op schijf. In tegenstelling tot Room werkt Core Data niet met tabellen, maar met beheerde objecten (NSManagedObject) die een hiërarchie van relaties vormen. Core Data ondersteunt lazy loading, ongedaan maken van wijzigingen en complexe query's via NSFetchRequest.

Core Data Stack

De basis van Core Data is een stack van drie componenten: beheerde context (NSManagedObjectContext), permanente opslag (NSPersistentStoreCoordinator) en datamodel (NSManagedObjectModel). NSPersistentContainer verenigt alle componenten in één enkel ingangspunt, waardoor de configuratie voor moderne Swift-apps wordt vereenvoudigd.

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

Bestandsopslag (File Storage) wordt gebruikt voor het opslaan van afbeeldingen, video's en documenten. Android biedt interne opslag (context.filesDir) — privé voor de app, en externe opslag (Environment.getExternalStorageDirectory) — toegankelijk voor andere apps. Op iOS worden bestanden opgeslagen in de mappen Documents en Library, waarbij Library/Caches bedoeld is voor cache die niet wordt geback-upt in iCloud. Voor het werken met bestanden bieden beide platforms File API en stream-lees-/schrijfbewerkingen. Moderne bibliotheken zoals Coil en SDWebImage voegen een cachelaag toe die bestandsopslag combineert met RAM voor optimale prestaties.

Op Android is het alternatief voor Core Data qua complexiteit en functionaliteit Realm — een objectgeoriënteerde database die rechtstreeks met modellen werkt zonder SQL-laag. Realm is sneller dan SQLite bij leesbewerkingen en ondersteunt live-objecten die de UI automatisch bijwerken bij gegevenswijzigingen.