rx-java Handledning
Komma igång med rx-java

Anmärkningar

versioner

Installation eller installation

rx-java konfigurerat

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. Murgröna

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

4. Snapshots från JFrog

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

5. Om du behöver ladda ner burkarna istället för att använda ett build-system, skapar du en Maven pom fil som den här med önskad version:

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

Kör sedan:

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

Det kommandot hämtar rxjava-*.jar och dess beroenden till ./target/dependency/.

Du behöver Java 6 eller senare.

Hej världen!

Följande skriver ut meddelandet Hello, World! att trösta

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

    });
}

Eller med Java 8 lambda notation

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

En introduktion till RxJava

Kärnbegreppen i RxJava är dess Observables och Subscribers . En Observable sänder ut objekt, medan en Subscriber konsumerar dem.

Märkbar

Observable är en klass som implementerar det reaktiva designmönstret. Dessa Observables tillhandahåller metoder som gör det möjligt för konsumenter att prenumerera på evenemangsändringar. Händelseändringarna utlöses av det observerbara. Det finns ingen begränsning för antalet prenumeranter som en Observable kan ha eller antalet objekt som en Observable kan avge.

Ta till exempel:

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

Här skapas ett observerbart objekt som kallas integerObservable och stringObservable från fabriksmetoden som just tillhandahålls av Rx-biblioteket. Lägg märke till att Observable är generisk och därmed kan avge alla objekt.

Abonnent

En Subscriber är konsumenten. En Subscriber kan bara prenumerera på en observerbar. Observable kallar onNext() , onCompleted() och onError() för 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);
        }
    };

Observera att Subscriber är generisk och kan stödja alla objekt. En Subscriber måste prenumerera på det observerbara genom att anropa subscribe på det observerbara.

integerObservable.subscribe(mSubscriber);

Ovanstående, vid körning, ger följande utgång:

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

Förstå marmordiagram

En observerbar kan betraktas som bara en ström av händelser. När du definierar en observerbar har du tre lyssnare: onNext, onComplete och onError. onNext kommer att ringas varje gång den observerbara förvärvar ett nytt värde. onComplete kommer att ringas om överordnade Observera meddelar att den slutade producera fler värden. onError kallas om ett undantag kastas när som helst under körningen av den observerbara kedjan. För att visa operatörer i Rx används marmordiagrammet för att visa vad som händer med en viss operation. Nedan följer ett exempel på en enkel observerbar operatör "Just".

Marmordiagram har ett horisontellt block som representerar operationen som utförs, en vertikal stapel för att representera den slutförda händelsen, ett X för att representera ett fel och varje annan form representerar ett värde. Med det i åtanke kan vi se att "Just" bara tar vårt värde och gör ett onNext och sedan slutar med onComplete. Det finns mycket fler åtgärder än bara "Bara". Du kan se alla operationer som ingår i ReactiveX-projektet och implementeringarna i RxJava på ReativeX-webbplatsen . Det finns också interaktiva marmordiagram via RxMarbles webbplats .