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">
</ph>
Abbildung 1: Diagramm der Architektur der Raumbibliothek.

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ält entities 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:

Produktproben

Codelabs

Blogs