Looking for rx-java Keywords? Try Ask4Keywords

rx-javaEmpezando con rx-java


Observaciones

Esta sección proporciona una descripción básica y una introducción superficial a rx-java.

RxJava es una implementación Java VM de Extensiones reactivas : una biblioteca para componer programas asíncronos y basados ​​en eventos mediante el uso de secuencias observables.

Aprenda más sobre RxJava en la página principal de Wiki .

Versiones

Versión Estado Última versión estable Fecha de lanzamiento
1.x Estable 1.3.0 2017-05-05
2.x Estable 2.1.1 2017-06-21

Una introducción a RxJava

Los conceptos centrales de RxJava son sus Observables y Subscribers . Un Observable emite objetos, mientras que un Subscriber consume.

Observable

Observable es una clase que implementa el patrón de diseño reactivo. Estos Observables proporcionan métodos que permiten a los consumidores suscribirse a cambios de eventos. Los cambios de evento son activados por lo observable. No hay restricción en el número de suscriptores que un Observable puede tener, o el número de objetos que un Observable puede emitir.

Tomar como ejemplo:

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

Aquí, un objeto observable llamado integerObservable y stringObservable se crean a partir del método de fábrica que just proporcionar la biblioteca Rx. Observe que Observable es genérico y, por lo tanto, puede emitir cualquier objeto.

Abonado

Un Subscriber es el consumidor. Un Subscriber puede suscribirse a un solo observable. El Observable llama a los onNext() , onCompleted() y onError() del 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);
        }
    };
 

Tenga en cuenta que el Subscriber también es genérico y puede admitir cualquier objeto. Un Subscriber debe suscribirse al observable llamando al método de subscribe en el observable.

integerObservable.subscribe(mSubscriber);
 

Lo anterior, cuando se ejecuta, producirá el siguiente resultado:

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

¡Hola Mundo!

A continuación se imprime el mensaje Hello, World! consolar

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

    });
}
 

O usando la notación lambda de Java 8

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

Instalación o configuración

configuración de rx-java

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

    <dependency org="io.reactivex.rxjava2" name="rxjava" rev="2.1.1" />
     
  4. Instantáneas de JFrog

    repositories {
    maven { url 'https://oss.jfrog.org/libs-snapshot' }
    }
    
    dependencies {
        compile 'io.reactivex:rxjava:2.0.0-SNAPSHOT'
    }
     
  5. Si necesita descargar los archivos jar en lugar de usar un sistema de compilación, cree un archivo pom Maven como este con la versión deseada:

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

Luego ejecuta:

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

Ese comando descarga rxjava-*.jar y sus dependencias en ./target/dependency/.

Necesitas Java 6 o posterior.

Entendiendo los diagramas de mármol

Un observable se puede considerar como un flujo de eventos. Cuando define un Observable, tiene tres escuchas: onNext, onComplete y onError. onNext se llamará cada vez que el observable adquiera un nuevo valor. Se llamará a onComplete si el Observable principal notifica que terminó de producir más valores. Se llama a onError si se lanza una excepción en cualquier momento durante la ejecución de la cadena Observable. Para mostrar los operadores en Rx, el diagrama de mármol se usa para mostrar lo que sucede con una operación en particular. A continuación se muestra un ejemplo de un simple operador observable "Just".

Ejemplo de un diagrama de mármol

Los diagramas de mármol tienen un bloque horizontal que representa la operación que se está realizando, una barra vertical para representar el evento completado, una X para representar un error y cualquier otra forma representa un valor. Con eso en mente, podemos ver que "Just" solo tomará nuestro valor y hará un onNext y luego terminará con onComplete. Hay muchas más operaciones que simplemente "solo". Puede ver todas las operaciones que forman parte del proyecto ReativeX y sus implementaciones en RxJava en el sitio de ReativeX . También hay diagramas de mármol interactivos a través del sitio RxMarbles .