Gebruik van Room Database | Android Jetpack

Nou laten we praten over Room

Room is een persistentiebibliotheek, onderdeel van het Android Jetpack.

Hier is de video van Android Developers Channel:

Room biedt een abstractielaag over SQLite om vloeiende databasetoegang mogelijk te maken terwijl de volledige kracht van SQLite wordt benut.

Room wordt nu beschouwd als een betere benadering voor datapersistentie dan SQLiteDatabase. Het wordt eenvoudiger om met SQLiteDatabase-objecten in uw app te werken, waardoor de hoeveelheid boilerplate-code afneemt en SQL-query’s tijdens het compileren worden geverifieerd.

• Compile-time verificatie van SQL-query’s. Elke @Query en @Entity wordt tijdens het compileren gecontroleerd, waardoor uw app tijdens het runtimen niet crasht en niet alleen de syntaxis wordt gecontroleerd, maar ook ontbrekende tabellen.
• Boilerplate code
• Gemakkelijk te integreren met andere Architecture componenten (zoals LiveData)

Grootste problemen met SQLite gebruik zijn

• Er is geen compile-time verificatie van ruwe SQL queries. Als u bijvoorbeeld een SQL query schrijft met een verkeerde kolomnaam die niet bestaat in de echte database, dan zal deze tijdens het uitvoeren een uitzondering geven en u kunt dit probleem niet tijdens het compileren vastleggen.
• Als uw schema verandert, moet u de betreffende SQL queries handmatig bijwerken. Dit proces kan tijdrovend en foutgevoelig zijn.
• U moet veel boilerplate-code gebruiken om te converteren tussen SQL-query’s en Java-dataobjecten (POJO).

Room vs SQLite

Room is een ORM, Object Relational Mapping-bibliotheek. Met andere woorden, Room mapt onze database objecten naar Java objecten. Room biedt een abstractielaag over SQLite om vloeiende databasetoegang mogelijk te maken, terwijl de volledige kracht van SQLite wordt benut.

Verschil tussen SQLite en Room persistentiebibliotheek:-

• In het geval van SQLite, is er geen compile-time verificatie van ruwe SQLite queries. Maar in Room is er SQL-validatie tijdens het compileren.
• U moet veel boilerplate-code gebruiken om te converteren tussen SQL-queries en Java-dataobjecten. Maar Room vertaalt onze databaseobjecten naar Java-objecten zonder boilerplate-code.
• Als uw schema verandert, moet u de betreffende SQL-query’s handmatig bijwerken. Room lost dit probleem op.
• Room is gebouwd om te werken met LiveData en RxJava voor data observatie, terwijl SQLite dat niet doet.

Componenten van Room DB

Room heeft drie hoofdcomponenten van Room DB :

• Entity
• Dao
• Database

Entity

Stelt een tabel voor binnen de database. Room maakt een tabel voor elke klasse die @Entity annotatie heeft, de velden in de klasse corresponderen met kolommen in de tabel. Daarom hebben de entiteitklassen de neiging om kleine modelklassen te zijn die geen logica bevatten.

Entities annotaties

Voordat we aan de slag gaan met het modelleren van onze entiteiten, moeten we een aantal nuttige annotaties en hun attributen kennen.

@Entity – elke modelklasse met deze annotatie zal een mapping tabel in de DB hebben

• foreignKeys – namen van foreign keys
• indices – lijst van aanduidingen op de tabel
• primaryKeys – namen van primaire sleutels van entiteiten
• tableName

@PrimaryKey – zoals de naam al aangeeft, wijst deze annotatie de primaire sleutel van de entiteit aan. autoGenerate – indien ingesteld op true, dan genereert SQLite een unieke id voor de kolom

@PrimaryKey(autoGenerate = true)

@ColumnInfo – maakt het mogelijk aangepaste informatie over de kolom op te geven

@ColumnInfo(name = "column_name")

@Ignore – veld wordt niet door Kamer bewaard

@Embeded – geneste velden kunnen direct in de SQL-query’s worden gebruikt.

Dao

DAO’s zijn verantwoordelijk voor het definiëren van de methoden die toegang krijgen tot de database. In de oorspronkelijke SQLite, gebruiken we de Cursor objecten. Met Room hebben we niet alle Cursor-gerelateerde code nodig en kunnen we eenvoudig onze queries definiëren met behulp van annotaties in de Dao-klasse.

Database

Bevat de databasehouder en dient als het belangrijkste toegangspunt voor de onderliggende verbinding met de persisted, relationele gegevens van uw app.

Om een database te maken, moeten we een abstracte klasse definiëren die RoomDatabase uitbreidt. Deze klasse is geannoteerd met @Database, bevat een lijst van de entiteiten in de database, en de DAO’s die toegang tot hen hebben.

De klasse die is geannoteerd met @Database moet aan de volgende voorwaarden voldoen:

• Een abstracte klasse zijn die RoomDatabase uitbreidt.
• Bevat de lijst van entiteiten die zijn gekoppeld aan de database binnen de annotatie.
• Bevat een abstracte methode die 0 argumenten heeft en de klasse retourneert die is geannoteerd met @Dao.

Tijdens runtime kunt u een instantie van Database verkrijgen door Room.databaseBuilder() ofRoom.inMemoryDatabaseBuilder() aan te roepen.

Stap 1: Voeg de Gradle-afhankelijkheden toe

1. Om deze aan uw project toe te voegen, opent u het bestand build.gradle op projectniveau en voegt u de gemarkeerde regel toe zoals hieronder wordt weergegeven:

2. Open het build.gradle-bestand voor uw app of module en voeg afhankelijkheden toe:

Stap 2: Maak een modelklas

Room maakt een tabel voor elke klasse die is geannoteerd met @Entity; de velden in de klasse corresponderen met kolommen in de tabel. Daarom zijn de entiteit klassen meestal kleine model klassen die geen logica bevatten. Onze Person klasse vertegenwoordigt het model voor de gegevens in de database. Dus laten we deze bijwerken om Room te vertellen dat het een tabel moet maken op basis van deze klasse:

• Annoteer de klasse met @Entity en gebruik de tableName eigenschap om de naam van de tabel in te stellen.
• Stel de primaire sleutel in door de @PrimaryKey annotatie toe te voegen aan de juiste velden – in ons geval is dit de ID van de gebruiker.
• Stel de naam van de kolommen voor de klasse velden in met behulp van de @ColumnInfo(name = "column_name") annotatie. Voel je vrij om deze stap over te slaan als je velden al de juiste kolomnaam hebben.
• Als meerdere constructors geschikt zijn, voeg dan de @Ignore annotatie toe om Room te vertellen welke gebruikt moeten worden en welke niet.

Stap 3: Maak Data Access Objects (DAO’s)

DAO’s zijn verantwoordelijk voor het definiëren van de methoden waarmee toegang tot de database wordt verkregen.

Om een DAO te maken, moeten we een interface maken en deze annoteren met @Dao .

Stap 4 – De database maken

Om een database te maken, moeten we een abstracte klasse definiëren die RoomDatabase uitbreidt. Deze klasse is geannoteerd met @Database, bevat een lijst van de entiteiten die zich in de database bevinden, en de DAO’s die toegang tot deze entiteiten hebben.

Stap 4: Gegevens beheren

Om de gegevens te beheren, moeten we allereerst een instantie van de database maken.

Dan kunnen we de database invoegen, verwijderen en bijwerken.

Zorg ervoor dat alle bewerkingen op een andere thread worden uitgevoerd. In mijn geval gebruik ik Executers (zie hier)

Query:

Insert:

Delete:

Update:

Uitvoeren met Executer

Ik heb ook een repo gelinkt als je het voorbeeld van de Room Database wilt zien.