rx-javaDémarrer avec rx-java


Remarques

Cette section fournit un aperçu de base et une introduction superficielle à rx-java.

RxJava est une implémentation Java de Reactive Extensions : une bibliothèque pour composer des programmes asynchrones et basés sur des événements en utilisant des séquences observables.

En savoir plus sur RxJava sur le Wiki Home .

Versions

Version Statut Dernière version stable Date de sortie
1 fois Stable 1.3.0 2017-05-05
2.x Stable 2.1.1 2017-06-21

Une introduction à RxJava

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

Observable

Observable est une classe qui implémente le modèle de conception réactif. Ces observables fournissent des méthodes permettant aux consommateurs de s’abonner aux modifications apportées aux événements. Les changements d'événement sont déclenchés par l'observable. Il n'y a pas de restriction quant au nombre d'abonnés qu'un Observable peut avoir ou au nombre d'objets qu'une 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 fabrication just fourni par la bibliothèque Rx. Notez que Observable est générique et peut donc émettre n'importe quel objet.

Abonné

Un Subscriber est le consommateur. Un Subscriber ne peut souscrire qu’à une seule observable. Observable appelle les onNext() , onCompleted() et onError() de l' 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 l' Subscriber est également générique et peut supporter n'importe quel objet. Un Subscriber doit souscrire à l'observable en appelant la méthode subscribe sur l'observable.

integerObservable.subscribe(mSubscriber);
 

Le ci-dessus, lorsqu'il est exécuté, produira la sortie suivante:

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

Bonjour le monde!

Ce qui suit imprime le message Hello, World! consoler

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);   
        });
}
 

Installation ou configuration

rx-java mis en place

  1. Gradle

    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 fichiers JAR au lieu d'utiliser un système de génération, 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>
     

Ensuite, exécutez:

$ 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 plus tard.

Comprendre les diagrammes de marbre

Un observable peut être considéré comme un simple flux d'événements. Lorsque vous définissez une 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 indique qu'il a fini de produire d'autres valeurs. onError est appelée si une exception est lancée à tout moment pendant l'exécution de la chaîne Observable. Pour afficher les opérateurs dans Rx, le diagramme de 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

Les diagrammes de marbre ont un bloc horizontal qui représente l'opération effectuée, une barre verticale représentant l'événement terminé, un X représentant une erreur et toute autre forme représentant une valeur. Dans cet esprit, nous pouvons voir que "Just" va simplement prendre notre valeur et faire un onNext, puis finir avec onComplete. Il y a beaucoup plus d'opérations que juste "juste". Vous pouvez voir toutes les opérations faisant partie du projet ReactiveX et leurs implémentations dans RxJava sur le site ReativeX . Il existe également des diagrammes de marbre interactifs via le site RxMarbles .