Looking for rx-java Answers? Try Ask4KnowledgeBase
Looking for rx-java Keywords? Try Ask4Keywords

rx-javaAan de slag met rx-java


Opmerkingen

Deze sectie biedt een basisoverzicht en een oppervlakkige inleiding tot rx-java.

RxJava is een Java VM-implementatie van Reactive Extensions : een bibliotheek voor het samenstellen van asynchrone en op gebeurtenissen gebaseerde programma's met behulp van waarneembare sequenties.

Meer informatie over RxJava op de Wiki Home .

versies

Versie Toestand Nieuwste stabiele versie Publicatiedatum
1.x Stal 1.3.0 2017/05/05
2.x Stal 2.1.1 2017/06/21

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!
 

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

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.

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

Voorbeeld van een marmeren diagram

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 .