rx-java Zelfstudie
Aan de slag met rx-java

Opmerkingen

versies

Installatie of instellingen

rx-java ingesteld

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

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

4. Snapshots van JFrog

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

5. Als je de potten moet downloaden in plaats van een buildsysteem te gebruiken, maak dan een Maven pom bestand zoals deze met de gewenste versie:

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

Voer vervolgens uit:

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

Dat commando downloadt rxjava-*.jar en zijn afhankelijkheden naar ./target/dependency/.

U hebt Java 6 of hoger nodig.

Hallo Wereld!

In het volgende wordt het bericht afgedrukt Hello, World! troosten

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

    });
}

Of met behulp van Java 8 lambda-notatie

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

Een inleiding tot RxJava

De kernconcepten van RxJava zijn de Observables en Subscribers . Een Observable zendt objecten uit, terwijl een Subscriber consumeert.

waarneembaar

Observable is een klasse die het reactieve ontwerppatroon implementeert. Deze Observables bieden methoden waarmee consumenten zich kunnen abonneren op evenementveranderingen. De gebeurtenisveranderingen worden veroorzaakt door het waarneembare. Er is geen beperking op het aantal abonnees dat een Observable kan hebben, of het aantal objecten dat een Observable kan uitzenden.

Neem bijvoorbeeld:

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

Hier wordt een waarneembaar object genaamd integerObservable en stringObservable gemaakt op basis van de fabrieksmethode die just door de Rx-bibliotheek is geleverd. Merk op dat Observable generiek is en dus elk object kan uitzenden.

Abonnee

Een Subscriber is de consument. Een Subscriber kan zich op slechts één waarneembare abonneren. De Observable roept de onNext() , onCompleted() en onError() van 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);
        }
    };

Merk op dat Subscriber ook generiek is en elk object kan ondersteunen. Een Subscriber moet zich abonneren op het waarneembare door de subscribe op het waarneembare aan te roepen.

integerObservable.subscribe(mSubscriber);

Het bovenstaande zal, wanneer uitgevoerd, de volgende uitvoer produceren:

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

Marmeren diagrammen begrijpen

Een Observable kan worden gezien als een stroom van evenementen. Wanneer u een Observable definieert, hebt u drie luisteraars: onNext, onComplete en onError. onNext zal worden aangeroepen telkens wanneer de waarneembare een nieuwe waarde verwerft. onComplete wordt aangeroepen als de bovenliggende Observable meldt dat het klaar is met het produceren van meer waarden. onError wordt opgeroepen als er tijdens de uitvoering van de waarneembare keten een uitzondering wordt gemaakt. Om operators in Rx te tonen, wordt het marmeren diagram gebruikt om weer te geven wat er met een bepaalde bewerking gebeurt. Hieronder is een voorbeeld van een eenvoudige waarneembare operator "Just".

Marmeren diagrammen hebben een horizontaal blok dat de uit te voeren bewerking weergeeft, een verticale balk om de voltooide gebeurtenis weer te geven, een X om een fout weer te geven en elke andere vorm vertegenwoordigt een waarde. Met dat in gedachten kunnen we zien dat "Just" gewoon onze waarde aanneemt en een onNext doet en dan eindigt met onComplete. Er zijn veel meer bewerkingen dan alleen "Just". U kunt alle bewerkingen die deel uitmaken van het ReactiveX-project en hun implementaties in RxJava zien op de ReativeX-site . Er zijn ook interactieve marmeren diagrammen via de RxMarbles-site .