rx-java Tutorial
Erste Schritte mit rx-java

Bemerkungen

Versionen

Installation oder Setup

rx-java eingerichtet

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. Efeu

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

4. Schnappschüsse von JFrog

   repositories {
   maven { url 'https://oss.jfrog.org/libs-snapshot' }
   }
   
   dependencies {
       compile 'io.reactivex:rxjava:2.0.0-SNAPSHOT'
   }
   

5. Wenn Sie die Gläser anstelle eines Build-Systems herunterladen müssen, erstellen Sie eine Maven- pom Datei mit der gewünschten Version wie pom :

   <?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>
   

Dann führe aus:

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

Dieser Befehl lädt rxjava-*.jar und seine Abhängigkeiten in ./target/dependency/.

Sie benötigen Java 6 oder höher.

Hallo Welt!

Folgendes druckt die Nachricht Hello, World! zu trösten

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

    });
}

Oder mit der Java 8-Lambda-Notation

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

Eine Einführung in RxJava

Die Kernkonzepte von RxJava sind die Observables und Subscribers . Ein Observable gibt Objekte aus, während ein Subscriber verbraucht.

Beobachtbar

Observable ist eine Klasse, die das reaktive Entwurfsmuster implementiert. Diese Observables bieten Methoden, mit denen Verbraucher Ereignisänderungen abonnieren können. Die Ereignisänderungen werden vom Beobachtbaren ausgelöst. Die Anzahl der Abonnenten, die ein Observable kann, oder die Anzahl der Objekte, die ein Observable ausgeben kann, ist nicht beschränkt.

Nehmen Sie zum Beispiel:

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

Hier wird ein beobachtbares Objekt namens integerObservable und stringObservable aus der Factory-Methode erstellt, die just von der Rx-Bibliothek bereitgestellt wird. Beachten Sie, dass Observable generisch ist und somit jedes Objekt ausgeben kann.

Teilnehmer

Ein Subscriber ist der Verbraucher. Ein Subscriber kann nur einen beobachtbaren abonnieren. Das Observable ruft die onNext() , onCompleted() und onError() des 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);
        }
    };

Beachten Sie, dass der Subscriber auch generisch ist und jedes Objekt unterstützen kann. Ein Subscriber muss das Observable abonnieren, indem er die subscribe Methode für das Observable aufruft.

integerObservable.subscribe(mSubscriber);

Wenn das obige ausgeführt wird, wird folgende Ausgabe erzeugt:

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

Marmordiagramme verstehen

Ein Observable kann als nur ein Ereignisstrom betrachtet werden. Wenn Sie ein Observable definieren, haben Sie drei Listener: onNext, onComplete und onError. onNext wird jedes Mal aufgerufen, wenn das Observable einen neuen Wert erhält. onComplete wird aufgerufen, wenn das übergeordnete Observable mitteilt, dass es keine weiteren Werte mehr erzeugt. onError wird aufgerufen, wenn während der Ausführung der Observable-Kette eine Ausnahme ausgelöst wird. Um Operatoren in Rx anzuzeigen, wird das Marmordiagramm verwendet, um anzuzeigen, was mit einer bestimmten Operation passiert. Nachfolgend finden Sie ein Beispiel für einen einfachen beobachtbaren Operator "Just".

Marmordiagramme haben einen horizontalen Block, der die ausgeführte Operation darstellt, einen vertikalen Balken, der das abgeschlossene Ereignis darstellt, ein X, um einen Fehler darzustellen, und jede andere Form repräsentiert einen Wert. In diesem Sinne können wir sehen, dass "Just" nur unseren Wert übernimmt und onNext ausführt und dann mit onComplete endet. Es gibt viel mehr Operationen als nur "Just". Sie können alle Vorgänge, die Teil des ReactiveX-Projekts sind, und die zugehörigen Implementierungen in RxJava auf der ReativeX-Site anzeigen . Es gibt auch interaktive Marmordiagramme über die RxMarbles-Site .