Premiers pas avec rx-java

Une introduction à RxJava

Les concepts de base de RxJava sont ses Observables et Subscribers. Un Observable émet des objets, tandis qu’un Subscriber les consomme.

Observable

Observable est une classe qui implémente le modèle de conception réactif. Ces Observables fournissent des méthodes qui permettent aux consommateurs de s’abonner aux changements d’événements. Les changements d’événement sont déclenchés par l’observable. Il n’y a aucune restriction quant au nombre d’abonnés qu’un Observable peut avoir, ou au nombre d’objets qu’un Observable peut émettre.

Prends pour exemple:

Observable<Integer> integerObservable = Observable.just(1, 2, 3); // Integer observable
Observable<String> stringObservable = Observable.just("Hello, ", "World", "!"); // String observable

Ici, un objet observable appelé integerObservable et stringObservable sont créés à partir de la méthode de fabrique just fournie par la bibliothèque Rx. Notez que Observable est générique et peut donc émettre n’importe quel objet.

Abonné

Un Abonné est le consommateur. Un Abonné ne peut s’abonner qu’à un seul observable. Observable appelle les méthodes onNext(), onCompleted() et onError() de Subscriber.

Subscriber<Integer> mSubscriber = new Subscriber<Integer>() {
        // NOTE THAT ALL THESE ARE CALLED BY THE OBSERVABLE
        @Override
        public void onCompleted() {
            // called when all objects are emitted
            System.out.println("onCompleted called!");
        }

        @Override
        public void onError(Throwable throwable) {
            // called when an error occurs during emitting objects
            System.out.println("onError called!");
        }

        @Override
        public void onNext(Integer integer) {
            // called for each object that is emitted
            System.out.println("onNext called with: " + integer);
        }
    };

Notez que Subscriber est également générique et peut prendre en charge n’importe quel objet. Un Subscriber doit s’abonner à l’observable en appelant la méthode subscribe sur l’observable.

integerObservable.subscribe(mSubscriber);

Ce qui précède, lorsqu’il est exécuté, produira la sortie suivante :

onNext called with: 1
onNext called with: 2
onNext called with: 3
onCompleted called!

Installation ou configuration

configuration de rx-java

  1. Graduation

     compile 'io.reactivex:rxjava2:rxjava:2.1.1'

  2. Maven

     <dependency>
     <groupId>io.reactivex.rxjava2</groupId>
     <artifactId>rxjava</artifactId>
     <version>2.1.1</version>
 </dependency>

  3. Lierre

     <dependency org="io.reactivex.rxjava2" name="rxjava" rev="2.1.1" />

  4. Instantanés de JFrog

     repositories {
 maven { url 'https://oss.jfrog.org/libs-snapshot' }
 }

 dependencies {
     compile 'io.reactivex:rxjava:2.0.0-SNAPSHOT'
 }

  5. Si vous avez besoin de télécharger les jars au lieu d’utiliser un système de construction, créez un fichier Maven pom comme celui-ci avec la version souhaitée :

     <?xml version="1.0"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.netflix.rxjava.download</groupId>
     <artifactId>rxjava-download</artifactId>
     <version>1.0-SNAPSHOT</version>
     <name>Simple POM to download rxjava and dependencies</name>
     <url>http://github.com/ReactiveX/RxJava</url>
     <dependencies>
         <dependency>
             <groupId>io.reactivex</groupId>
             <artifactId>rxjava</artifactId>
             <version>2.0.0</version>
             <scope/>
         </dependency>
     </dependencies>
 </project>

Exécutez ensuite :

$ mvn -f download-rxjava-pom.xml dependency:copy-dependencies

Cette commande télécharge rxjava-*.jar et ses dépendances dans ./target/dependency/.

Vous avez besoin de Java 6 ou version ultérieure.

Bonjour le monde!

Ce qui suit imprime le message “Hello, World!” sur la console

public void hello() {
  Observable.just("Hello, World!") // create new observable
    .subscribe(new Action1<String>() { // subscribe and perform action

       @Override
       public void call(String st) {
         System.out.println(st);
       }

    });
}

Ou en utilisant la notation Java 8 lambda

public void hello() {
      Observable.just("Hello, World!") // create new observable
        .subscribe(onNext -> { // subscribe and perform action
             System.out.println(onNext);   
        });
}

Comprendre les diagrammes de marbre

Un observable peut être considéré comme un simple flux d’événements. Lorsque vous définissez un Observable, vous disposez de trois écouteurs : onNext, onComplete et onError. onNext sera appelé chaque fois que l’observable acquiert une nouvelle valeur. onComplete sera appelé si le parent Observable notifie qu’il a fini de produire d’autres valeurs. onError est appelé si une exception est levée à tout moment pendant l’exécution de la chaîne Observable. Pour afficher les opérateurs dans Rx, le diagramme en marbre est utilisé pour afficher ce qui se passe avec une opération particulière. Vous trouverez ci-dessous un exemple d’un simple opérateur observable “Just”.

[![Exemple de diagramme en marbre][1]][1]

Les diagrammes en marbre ont un bloc horizontal qui représente l’opération en cours d’exécution, une barre verticale pour représenter l’événement terminé, un X pour représenter une erreur et toute autre forme représente une valeur. Dans cet esprit, nous pouvons voir que “Just” prendra simplement notre valeur et fera un onNext puis terminera avec onComplete. Il y a beaucoup plus d’opérations que “juste”. Vous pouvez voir toutes les opérations qui font partie du projet ReactiveX et leurs implémentations dans RxJava sur le [site ReativeX][2]. Il existe également des diagrammes de marbre interactifs via [site RxMarbles] [3].

[1] : http://i.stack.imgur.com/Mixu4.png [2] : http://reactivex.io/documentation/operators.html [3] : http://rxmarbres.com/

Contre-pression →