Daten in einer lokalen Datenbank mit Room speichern Teil von Android Jetpack
Apps, die mit nicht einfachen Mengen strukturierter Daten umgehen, können stark von dass diese Daten lokal gespeichert werden. Am häufigsten werden relevante Daten im Cache gespeichert, Wenn das Gerät keinen Zugriff auf das Netzwerk hat, kann der Nutzer diese Inhalte auch offline ansehen.
Die Room-Persistenzbibliothek bietet eine Abstraktionsschicht über SQLite, flüssigen Datenbankzugriff und die volle Leistung von SQLite nutzen. Insbesondere Der Raum bietet folgende Vorteile:
- Überprüfung der Kompilierungszeit von SQL-Abfragen
- Praktische Anmerkungen, mit denen sich wiederholende und fehleranfällige Textbausteine minimiert werden Code.
- Optimierte Pfade für die Datenbankmigration
Daher empfehlen wir Ihnen dringend, stattdessen „Room“ zu verwenden. direkte Verwendung der SQLite-APIs.
Einrichten
Wenn Sie Room in Ihrer App verwenden möchten, fügen Sie die folgenden Abhängigkeiten zum
build.gradle
-Datei:
Cool
dependencies { def room_version = "2.6.1" implementation "androidx.room:room-runtime:$room_version" annotationProcessor "androidx.room:room-compiler:$room_version" // To use Kotlin annotation processing tool (kapt) kapt "androidx.room:room-compiler:$room_version" // To use Kotlin Symbol Processing (KSP) ksp "androidx.room:room-compiler:$room_version" // optional - RxJava2 support for Room implementation "androidx.room:room-rxjava2:$room_version" // optional - RxJava3 support for Room implementation "androidx.room:room-rxjava3:$room_version" // optional - Guava support for Room, including Optional and ListenableFuture implementation "androidx.room:room-guava:$room_version" // optional - Test helpers testImplementation "androidx.room:room-testing:$room_version" // optional - Paging 3 Integration implementation "androidx.room:room-paging:$room_version" }
Kotlin
dependencies { val room_version = "2.6.1" implementation("androidx.room:room-runtime:$room_version") annotationProcessor("androidx.room:room-compiler:$room_version") // To use Kotlin annotation processing tool (kapt) kapt("androidx.room:room-compiler:$room_version") // To use Kotlin Symbol Processing (KSP) ksp("androidx.room:room-compiler:$room_version") // optional - Kotlin Extensions and Coroutines support for Room implementation("androidx.room:room-ktx:$room_version") // optional - RxJava2 support for Room implementation("androidx.room:room-rxjava2:$room_version") // optional - RxJava3 support for Room implementation("androidx.room:room-rxjava3:$room_version") // optional - Guava support for Room, including Optional and ListenableFuture implementation("androidx.room:room-guava:$room_version") // optional - Test helpers testImplementation("androidx.room:room-testing:$room_version") // optional - Paging 3 Integration implementation("androidx.room:room-paging:$room_version") }
Hauptkomponenten
Raum besteht aus drei Hauptkomponenten:
- Die Datenbankklasse, die die Datenbank und dient als Hauptzugriffspunkt für die zugrunde liegende Verbindung zu die persistenten Daten Ihrer App.
- Datenentitäten, die Folgendes repräsentieren: Tabellen in der Datenbank Ihrer Anwendung.
- Datenzugriffsobjekte (DAOs), die Methoden zum Abfragen, Aktualisieren, Einfügen und Löschen in deiner App anbieten in der Datenbank speichern.
Die Datenbankklasse stellt Ihrer Anwendung Instanzen der DAOs bereit, die mit Datenbank. Die App wiederum kann mithilfe der DAOs Daten aus dem Datenbank als Instanzen der verknüpften Datenentitätsobjekte. Die App kann auch Verwenden Sie die definierten Datenentitäten, um Zeilen aus den entsprechenden Tabellen zu aktualisieren, oder um neue einzufügende Zeilen zu erstellen. In Abbildung 1 sehen Sie die Beziehung zwischen verschiedenen Komponenten von Raum.
<ph type="x-smartling-placeholder">![](https://developer.android.com/static/images/training/data-storage/room_architecture.png?authuser=0000&hl=de)
Implementierungsbeispiel
In diesem Abschnitt wird eine Beispielimplementierung einer Raumdatenbank mit einer Datenentität und einen einzigen DAO.
Datenentität
Mit dem folgenden Code wird eine User
-Datenentität definiert. Jede Instanz von User
stellt eine Zeile in einer user
-Tabelle in der Datenbank der Anwendung dar.
Kotlin
@Entity data class User( @PrimaryKey val uid: Int, @ColumnInfo(name = "first_name") val firstName: String?, @ColumnInfo(name = "last_name") val lastName: String? )
Java
@Entity public class User { @PrimaryKey public int uid; @ColumnInfo(name = "first_name") public String firstName; @ColumnInfo(name = "last_name") public String lastName; }
Weitere Informationen zu Datenentitäten in Chatroom finden Sie unter Daten mit Chatroom definieren Entitäten
Datenzugriffsobjekt (DAO)
Mit dem folgenden Code wird ein DAO mit dem Namen UserDao
definiert. UserDao
stellt die
Methoden, die die restliche App verwendet, um mit Daten in der Tabelle user
zu interagieren.
Kotlin
@Dao interface UserDao { @Query("SELECT * FROM user") fun getAll(): List<User> @Query("SELECT * FROM user WHERE uid IN (:userIds)") fun loadAllByIds(userIds: IntArray): List<User> @Query("SELECT * FROM user WHERE first_name LIKE :first AND " + "last_name LIKE :last LIMIT 1") fun findByName(first: String, last: String): User @Insert fun insertAll(vararg users: User) @Delete fun delete(user: User) }
Java
@Dao public interface UserDao { @Query("SELECT * FROM user") List<User> getAll(); @Query("SELECT * FROM user WHERE uid IN (:userIds)") List<User> loadAllByIds(int[] userIds); @Query("SELECT * FROM user WHERE first_name LIKE :first AND " + "last_name LIKE :last LIMIT 1") User findByName(String first, String last); @Insert void insertAll(User... users); @Delete void delete(User user); }
Weitere Informationen zu DAOs finden Sie unter Über Chatrooms auf Daten zugreifen DAOs
Datenbank
Mit dem folgenden Code wird eine AppDatabase
-Klasse für die Datenbank definiert.
AppDatabase
definiert die Datenbankkonfiguration und dient als Hauptanwendung der App
auf die persistenten Daten zugreifen. Die Datenbankklasse muss die
folgenden Bedingungen:
- Die Klasse muss mit einem
Anmerkung
@Database
, die enthältentities
Array, das alle mit der Datenbank verknüpften Datenentitäten auflistet. - Die Klasse muss eine abstrakte Klasse sein, die
RoomDatabase
- Die Datenbankklasse für jede mit der Datenbank verknüpfte DAO-Klasse muss eine abstrakte Methode definieren, die keine Argumente hat und eine Instanz zurückgibt der DAO-Klasse.
Kotlin
@Database(entities = [User::class], version = 1) abstract class AppDatabase : RoomDatabase() { abstract fun userDao(): UserDao }
Java
@Database(entities = {User.class}, version = 1) public abstract class AppDatabase extends RoomDatabase { public abstract UserDao userDao(); }
Hinweis : Wenn Ihre App in einem einzigen Prozess ausgeführt wird, folgen Sie den
Singleton-Designmuster bei der Instanziierung eines AppDatabase
-Objekt enthält. Jede RoomDatabase
-Instanz ist ziemlich teuer und Sie
benötigen nur selten Zugriff auf mehrere Instanzen innerhalb eines
einzelnen Prozesses.
Wenn Ihre App in mehreren Prozessen ausgeführt wird, fügen Sie
enableMultiInstanceInvalidation()
in Ihrem Datenbank-Builder
. Auf diese Weise, wenn Sie eine Instanz von AppDatabase
haben,
können Sie die gemeinsame Datenbankdatei
in einem Prozess entwerten.
Diese Entwertung wird
automatisch auf die Instanzen
AppDatabase
innerhalb anderer Prozesse.
Nutzung
Nachdem Sie die Datenentität, den DAO und das Datenbankobjekt definiert haben, können Sie mit dem folgenden Code eine Instanz der Datenbank erstellen:
Kotlin
val db = Room.databaseBuilder( applicationContext, AppDatabase::class.java, "database-name" ).build()
Java
AppDatabase db = Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "database-name").build();
Sie können dann die abstrakten Methoden aus dem AppDatabase
verwenden, um eine Instanz abzurufen.
des DAO. Sie können wiederum die Methoden der DAO-Instanz verwenden,
mit der Datenbank:
Kotlin
val userDao = db.userDao() val users: List<User> = userDao.getAll()
Java
UserDao userDao = db.userDao(); List<User> users = userDao.getAll();
Weitere Informationen
Weitere Informationen zu Chatroom finden Sie in den folgenden Ressourcen: