Esecuzione di query in Room con RxJava

Meno codice boilerplate, query SQL verificate in fase di compilazione e, soprattutto, la potenza delle query asincrone e osservabili: come suona? Tutto ciò è possibile con Room , la libreria di persistenza di Architecture Components . Le query asincrone restituiscono LiveData o RxJava Forse , Single o Flowable . Le query che restituiscono LiveData e Flowable sono query osservabili. Ti consentono di ottenere aggiornamenti automatici ogni volta che i dati cambiano per assicurarti che la tua interfaccia utente rifletta i valori più recenti dal tuo database. Se stai già lavorando con RxJava 2 nella tua app, utilizzare Room insieme a Maybe, Singlee Flowablesarà un gioco da ragazzi.

Modifica successiva: a partire da `2.0.0-beta01`, anche Room supporta Observable

Successivamente modificare 2: a partire da camera 2.1.0-alpha01, metodi DAO annotate con @Insert, @Deleteo @Updatedi supporto tipi Rx di ritorno Completable, Single<T>e Maybe<T>.

Consideriamo la seguente interfaccia utente: l'utente è in grado di vedere e modificare il proprio nome utente. Questa, insieme ad altre informazioni sull'utente, viene salvata nel database. Ecco come inserire, aggiornare, eliminare e interrogare l'utente.

Inserire

L'integrazione di Room con RxJava consente i seguenti tipi di restituzione corrispondenti per l'inserimento:

• Completable- dove onCompleteviene chiamato non appena è stato effettuato l'inserimento
• Single<Long>oppure Maybe<Long>- dove il valore emesso su onSuccessè l'id riga dell'elemento inserito
• Single<List<Long>>oppure Maybe<List<Long>>- dove il valore emesso su onSuccessè l'elenco degli id ​​di riga degli elementi inseriti

@Insert
Completable insert(User user);
// or
@Insert
Maybe<Long> insert(User user);
// or
@Insert
Single<Long> insert(User[] user);
// or
@Insert
Maybe<List<Long>> insert(User[] user);
// or
@Insert
Single<List<Long>> insert(User[] user);

Aggiorna / Elimina

L'integrazione della stanza con RxJava consente i seguenti tipi di restituzione corrispondenti per l'aggiornamento / eliminazione:

• Completable- dove onCompleteviene chiamato non appena l'aggiornamento / cancellazione è stato effettuato
• Single<Integer>oppure Maybe<Integer>- dove il valore emesso su onSuccess è il numero di righe interessate dall'aggiornamento / eliminazione

@Update
Completable update(User user);
// or
@Update
Single<Integer> update(User user);
// or
@Update
Single<Integer> updateAll(User[] user);
// or
@Delete
Single<Integer> deleteAll(User[] user);
// or
@Delete
Single<Integer> deleteAll(User[] user);

Per ottenere l'utente dal database, potremmo scrivere la seguente query nell'oggetto di accesso ai dati class ( UserDao):

@Query(“SELECT * FROM Users WHERE id = :userId”)
User getUserById(String userId);

1. È una chiamata bloccante e sincrona
2. Dobbiamo chiamare manualmente questo metodo ogni volta che i nostri dati utente vengono modificati

Se sei preoccupato per i thread, Room ti tiene a tuo agio e garantisce che le query osservabili vengano eseguite fuori dal thread principale . Sta a te decidere su quale thread vengono emessi gli eventi a valle, impostando Schedulernel observeOnmetodo.

Per le query che restituiscono Maybeo Single, assicurati di chiamare subscribeOncon un diverso Schedulerda AndroidSchedulers.mainThread().

Per iniziare a utilizzare Room con RxJava 2, aggiungi le seguenti dipendenze al tuo build.gradlefile:

// RxJava support for Room
implementation “android.arch.persistence.room:rxjava2:1.0.0-alpha5”
// Testing support
androidTestImplementation “android.arch.core:core-testing:1.0.0-alpha5”

@Query(“SELECT * FROM Users WHERE id = :userId”)
Maybe<User> getUserById(String userId);

1. Quando non ci sono utenti nel database e la query non restituisce righe, Maybeverrà completata .
2. Quando c'è un utente nel database , Maybesi attiverà onSuccesse si completerà .
3. Se l' utente viene aggiornato dopo il Maybecompletamento, non accade nulla .

@Query(“SELECT * FROM Users WHERE id = :userId”)
Single<User> getUserById(String userId);

1. Quando non ci sono utenti nel database e la query non restituisce righe, Singlesi attiveràonError(EmptyResultSetException.class)
2. Quando c'è un utente nel database , Singlesi attiverà onSuccess.
3. Se l' utente viene aggiornato dopo il Singlecompletamento, non accade nulla .

@Query(“SELECT * FROM Users WHERE id = :userId”)
Flowable<User> getUserById(String userId);

1. Quando non è presente alcun utente nel database e la query non restituisce righe, Flowablenon verrà emesso , né onNext, né onError.
2. Quando c'è un utente nel database , Flowablesi attiverà onNext.
3. Ogni volta che i dati dell'utente vengono aggiornati , l' Flowableoggetto verrà emesso automaticamente , consentendo di aggiornare l'interfaccia utente in base ai dati più recenti.

Testare una query che restituisce un Maybe/ Single/ Flowablenon è molto diverso dal testare il suo equivalente sincrono. In UserDaoTest, ci assicuriamo di utilizzare un database in memoria, poiché le informazioni archiviate qui vengono cancellate automaticamente quando il processo viene terminato.

@RunWith(AndroidJUnit4.class)
public class UserDaoTest {
…
private UsersDatabase mDatabase;
@Before
public void initDb() throws Exception {
    mDatabase = Room.inMemoryDatabaseBuilder(
                     InstrumentationRegistry.getContext(),
                     UsersDatabase.class)
            // allowing main thread queries, just for testing
            .allowMainThreadQueries()
            .build();
}

@After
public void closeDb() throws Exception {
    mDatabase.close();
}

@Rule
public InstantTaskExecutorRule instantTaskExecutorRule = 
                                      new InstantTaskExecutorRule();

@Test
public void insertAndGetUserById() {
    // Given that we have a user in the data source
    mDatabase.userDao().insertUser(USER);
// When subscribing to the emissions of user
    mDatabase.userDao()
             .getUserById(USER.getId())
             .test()
             // assertValue asserts that there was only one emission
             .assertValue(new Predicate<User>() {
                @Override
                public boolean test(User user) throws Exception {
                    // The emitted user is the expected one
                    return user.getId().equals(USER.getId()) &&
                      user.getUserName().equals(USER.getUserName());
                }
            });
}