Combinaison d’observables dans RxJava

Combinaison d'observables dans RxJava

1. introduction

Dans ce rapide didacticiel, nous aborderons différentes manières de combiner desObservables dans RxJava.

Si vous êtes nouveau sur RxJava, commencez par vérifier ceintro tutorial.

Maintenant, allons-y.

2. Observables

Les séquencesObservable, ou simplementObservables, sont des représentations de flux de données asynchrones.

Celles-ci sont basées sur lesObserver pattern dans lesquels un objet appeléObserver s'abonne aux éléments émis par unObservable.

L'abonnement est non bloquant car lesObserver sont prêts à réagir à tout ce que lesObservable émettront à l'avenir. Ceci, à son tour, facilite la concurrence.

Voici une démonstration simple dans RxJava:

Observable
  .from(new String[] { "John", "Doe" })
  .subscribe(name -> System.out.println("Hello " + name))

3. Combinaison d'observables

Lors de la programmation à l’aide d’un framework réactif, il est courant de combiner diversObservables.

Dans une application Web, par exemple, nous pouvons avoir besoin de deux ensembles de flux de données asynchrones indépendants l'un de l'autre.

Au lieu d'attendre la fin du flux précédent avant de demander le flux suivant, nous pouvons appeler les deux en même temps et nous abonner aux flux combinés.

Dans cette section, nous allons discuter de certaines des différentes façons dont nous pouvons combiner plusieursObservables dans RxJava et des différents cas d'utilisation auxquels chaque méthode s'applique.

3.1. Merge

Nous pouvons utiliser l'opérateurmerge pour combiner la sortie de plusieursObservables afin qu'ils agissent comme un:

@Test
public void givenTwoObservables_whenMerged_shouldEmitCombinedResults() {
    TestSubscriber testSubscriber = new TestSubscriber<>();

    Observable.merge(
      Observable.from(new String[] {"Hello", "World"}),
      Observable.from(new String[] {"I love", "RxJava"})
    ).subscribe(testSubscriber);

    testSubscriber.assertValues("Hello", "World", "I love", "RxJava");
}

3.2. MergeDelayError

La méthodemergeDelayError est la même quemerge en ce qu'elle combine plusieursObservables en un seul, maisif errors occur during the merge, it allows error-free items to continue before propagating the errors:

@Test
public void givenMutipleObservablesOneThrows_whenMerged_thenCombineBeforePropagatingError() {
    TestSubscriber testSubscriber = new TestSubscriber<>();

    Observable.mergeDelayError(
      Observable.from(new String[] { "hello", "world" }),
      Observable.error(new RuntimeException("Some exception")),
      Observable.from(new String[] { "rxjava" })
    ).subscribe(testSubscriber);

    testSubscriber.assertValues("hello", "world", "rxjava");
    testSubscriber.assertError(RuntimeException.class);
}

L'exemple ci-dessusemits all the error-free values:

hello
world
rxjava

Notez que si nous utilisonsmerge au lieu demergeDelayError, lesString «rxjava” ne seront pas émis carmerge arrête immédiatement le flux de données deObservables lorsqu'une erreur se produit.

3.3. Zip

La méthode d'extensionzipbrings together two sequences of values as pairs:

@Test
public void givenTwoObservables_whenZipped_thenReturnCombinedResults() {
    List zippedStrings = new ArrayList<>();

    Observable.zip(
      Observable.from(new String[] { "Simple", "Moderate", "Complex" }),
      Observable.from(new String[] { "Solutions", "Success", "Hierarchy"}),
      (str1, str2) -> str1 + " " + str2).subscribe(zippedStrings::add);

    assertThat(zippedStrings).isNotEmpty();
    assertThat(zippedStrings.size()).isEqualTo(3);
    assertThat(zippedStrings).contains("Simple Solutions", "Moderate Success", "Complex Hierarchy");
}

3.4. Zip avec intervalle

Dans cet exemple, nous allons compresser un flux avecinterval qui retardera en effet l'émission des éléments du premier flux:

@Test
public void givenAStream_whenZippedWithInterval_shouldDelayStreamEmmission() {
    TestSubscriber testSubscriber = new TestSubscriber<>();

    Observable data = Observable.just("one", "two", "three", "four", "five");
    Observable interval = Observable.interval(1L, TimeUnit.SECONDS);

    Observable
      .zip(data, interval, (strData, tick) -> String.format("[%d]=%s", tick, strData))
      .toBlocking().subscribe(testSubscriber);

    testSubscriber.assertCompleted();
    testSubscriber.assertValueCount(5);
    testSubscriber.assertValues("[0]=one", "[1]=two", "[2]=three", "[3]=four", "[4]=five");
}

4. Sommaire

Dans cet article, nous avons vu quelques-unes des méthodes pour combinerObservables avec RxJava. Vous pouvez en apprendre davantage sur d'autres méthodes commecombineLatest,join,groupJoin,switchOnNext, dans lesofficial RxJava documentation.

Comme toujours, le code source de cet article est disponible dans nosGitHub repo.

TOC

Combinaison d’observables dans RxJava