Asynchrone DAO-Abfragen schreiben

Um zu verhindern, dass Abfragen die Benutzeroberfläche blockieren, erlaubt Room keinen Datenbankzugriff auf im Hauptthread. Diese Einschränkung bedeutet, dass Sie Ihren DAO asynchron ausführen. Raum enthält Integrationen in verschiedene Frameworks, asynchrone Abfrageausführung.

DAO-Abfragen lassen sich in drei Kategorien unterteilen:

  • Einmal schreiben-Abfragen, die Daten in die Datenbank einfügen, aktualisieren oder löschen.
  • One-Shot-Leseabfragen, bei denen Daten nur einmal aus Ihrer Datenbank gelesen und diese dann zurückgegeben werden ein Ergebnis mit dem Snapshot der Datenbank zu diesem Zeitpunkt.
  • Beobachtbare Leseabfragen, bei denen jedes Mal, wenn der ändern sich die zugrunde liegenden Datenbanktabellen und geben neue Werte aus, um diese Änderungen.

Sprach- und Frameworkoptionen

Der Chatroom bietet Unterstützung für die Interoperabilität mit einer bestimmten Sprache Funktionen und Bibliotheken. Die folgende Tabelle zeigt anwendbare Rückgabetypen basierend auf zum Abfragetyp und zum Framework:

Abfragetyp Kotlin-Sprachfunktionen RxJava Guava Jetpack-Lebenszyklus
One-Shot-Write Koroutinen (suspend) Single<T>, Maybe<T>, Completable ListenableFuture<T> –
Einmaliges Lesen Koroutinen (suspend) Single<T>, Maybe<T> ListenableFuture<T> –
Observable read Flow<T> Flowable<T>, Publisher<T>, Observable<T> – LiveData<T>

In diesem Leitfaden werden drei Möglichkeiten beschrieben, wie Sie diese Integrationen verwenden können, um asynchrone Abfragen in Ihren DAOs zu implementieren.

Kotlin mit Flow und Couroutinen

Kotlin bietet Sprachfunktionen, mit denen Sie asynchrone Abfragen schreiben können. ohne Drittanbieter-Frameworks:

  • In Room 2.2 und höher können Sie die Flow-Funktion von Kotlin verwenden, um beobachtbare Abfragen zu schreiben.
  • In Raum 2.1 und höher können Sie das Schlüsselwort suspend verwenden, um Ihren DAO zu erstellen. Abfragen, die mit Kotlin-Koroutinen asynchron sind

Java mit RxJava

Wenn Sie in Ihrer App die Programmiersprache Java verwenden, können Sie spezielle Rückgabetypen aus dem RxJava-Framework verwenden, um asynchrone DAO-Methoden zu schreiben. Zimmer bieten Unterstützung für die folgenden RxJava 2-Rückgabetypen:

Außerdem unterstützt Room 2.3 und höher RxJava 3.

Java mit LiveData und Guava

Wenn Ihre App die Programmiersprache Java verwendet und Sie das RxJava-Framework verwenden, können Sie die folgenden Alternativen verwenden, um asynchrone Suchanfragen:

  • Sie können den LiveData-Wrapper verwenden aus Jetpack, um asynchrone, beobachtbare Abfragen zu schreiben.
  • Sie können die ListenableFuture<T> Wrapper von Guava verwendet, um asynchrone One-Shot-Abfragen zu schreiben.

Asynchrone Einmalabfragen schreiben

One-Shot-Abfragen sind Datenbankvorgänge, die nur einmal ausgeführt werden und einen Snapshot erfassen von Daten zum Zeitpunkt der Ausführung. Hier sind einige Beispiele für asynchrone One-Shot-Abfragen:

Kotlin

@Dao
interface UserDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUsers(vararg users: User)

    @Update
    suspend fun updateUsers(vararg users: User)

    @Delete
    suspend fun deleteUsers(vararg users: User)

    @Query("SELECT * FROM user WHERE id = :id")
    suspend fun loadUserById(id: Int): User

    @Query("SELECT * from user WHERE region IN (:regions)")
    suspend fun loadUsersByRegion(regions: List<String>): List<User>
}

Java

@Dao
public interface UserDao {
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    public Completable insertUsers(List<User> users);

    @Update
    public Completable updateUsers(List<User> users);

    @Delete
    public Completable deleteUsers(List<User> users);

    @Query("SELECT * FROM user WHERE id = :id")
    public Single<User> loadUserById(int id);

    @Query("SELECT * from user WHERE region IN (:regions)")
    public Single<List<User>> loadUsersByRegion(List<String> regions);
}

Java

@Dao
public interface UserDao {
    // Returns the number of users inserted.
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    public ListenableFuture<Integer> insertUsers(List<User> users);

    // Returns the number of users updated.
    @Update
    public ListenableFuture<Integer> updateUsers(List<User> users);

    // Returns the number of users deleted.
    @Delete
    public ListenableFuture<Integer> deleteUsers(List<User> users);

    @Query("SELECT * FROM user WHERE id = :id")
    public ListenableFuture<User> loadUserById(int id);

    @Query("SELECT * from user WHERE region IN (:regions)")
    public ListenableFuture<List<User>> loadUsersByRegion(List<String> regions);
}

Beobachtbare Abfragen schreiben

Beobachtbare Abfragen sind Lesevorgänge, die immer neue Werte ausgeben, Änderungen an den Tabellen, auf die sich die Abfrage bezieht. Eine Möglichkeit, können Sie die angezeigte Liste der Artikel auf dem neuesten Stand halten. in der zugrunde liegenden Datenbank eingefügt, aktualisiert oder entfernt werden. Hier sind einige Beispiele für beobachtbare Abfragen:

Kotlin

@Dao
interface UserDao {
    @Query("SELECT * FROM user WHERE id = :id")
    fun loadUserById(id: Int): Flow<User>

    @Query("SELECT * from user WHERE region IN (:regions)")
    fun loadUsersByRegion(regions: List<String>): Flow<List<User>>
}

Java

@Dao
public interface UserDao {
    @Query("SELECT * FROM user WHERE id = :id")
    public Flowable<User> loadUserById(int id);

    @Query("SELECT * from user WHERE region IN (:regions)")
    public Flowable<List<User>> loadUsersByRegion(List<String> regions);
}

Java

@Dao
public interface UserDao {
    @Query("SELECT * FROM user WHERE id = :id")
    public LiveData<User> loadUserById(int id);

    @Query("SELECT * from user WHERE region IN (:regions)")
    public LiveData<List<User>> loadUsersByRegion(List<String> regions);
}

Weitere Informationen

Weitere Informationen zu asynchronen DAO-Abfragen finden Sie in den folgenden zusätzlichen Ressourcen:

Produktproben

Blogs

Zurück
Beziehungen zwischen Objekten definieren
Weiter
Ansichten in einer Datenbank erstellen