rx-java
Osservabile

Crea un osservabile

Esistono diversi modi per creare un Observable in RxJava. Il modo più efficace è utilizzare il metodo Observable.create . Ma è anche il modo più complicato . Quindi devi evitare di usarlo , per quanto possibile.

Emissione di un valore eccitante

Se hai già un valore, puoi utilizzare Observable.just per emettere il tuo valore.

 Observable.just("Hello World").subscribe(System.out::println);

Emissione di un valore che dovrebbe essere calcolato

Se si desidera emettere un valore che non è già calcolato, o che può richiedere molto tempo per essere calcolato, è possibile utilizzare Observable.fromCallable per emettere il valore successivo.

Observable.fromCallable(() -> longComputation()).subscribe(System.out::println);

longComputation() sarà chiamato solo quando ti iscrivi al tuo Observable . In questo modo, il calcolo sarà pigro .

Modo alternativo per emettere un valore che dovrebbe essere calcolato

Observable.defer costruisce un Observable come Observable.fromCallable ma viene utilizzato quando è necessario restituire un Observable anziché un valore. È utile quando vuoi gestire gli errori nella tua chiamata.

Observable.defer(() -> {
          try {
                return Observable.just(longComputation());
          } catch(SpecificException e) {
                return Observable.error(e);
          }).subscribe(System.out::println);

Osservabili caldi e freddi

Gli osservabili sono generalmente classificati come Hot o Cold , a seconda del loro comportamento di emissione.
Un Cold Observable è uno che inizia a emettere su richiesta (abbonamento), mentre un Hot Observable è uno che emette indipendentemente dalle sottoscrizioni.

Osservabile a freddo

/* Demonstration of a Cold Observable */
Observable<Long> cold = Observable.interval(500, TimeUnit.MILLISECONDS); // emits a long every 500 milli seconds
cold.subscribe(l -> System.out.println("sub1, " + l)); // subscriber1
Thread.sleep(1000); // interval between the two subscribes
cold.subscribe(l -> System.out.println("sub2, " + l)); // subscriber2

L'output del codice sopra sembra (può variare):

sub1, 0    -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 0    -> subscriber2 starts
sub1, 3
sub2, 1
sub1, 4
sub2, 2

Si noti che anche se sub2 inizia tardi, riceve valori dall'inizio. Per concludere, un Cold Observable emette solo gli articoli quando richiesto. Più richiesta avvia più pipeline.

Osservabile caldo

Un Cold Observale può essere convertito in Hot Observable con una semplice publish .

Observable.interval(500, TimeUnit.MILLISECONDS)
    .publish(); // publish converts cold to hot

publish restituisce un ConnectableObservable che aggiunge funzionalità per connettersi e disconnettersi dall'osservabile.

ConnectableObservable<Long> hot = Observable
                                    .interval(500, TimeUnit.MILLISECONDS)
                                    .publish(); // returns ConnectableObservable
hot.connect(); // connect to subscribe

hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));

I suddetti rendimenti:

sub1, 0  -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 2  -> subscriber2 starts
sub1, 3
sub2, 3

Notare che anche se sub2 inizia a osservare in ritardo, è sincronizzato con sub1 .
La disconnessione è un po 'più complicata! La disconnessione avviene Subscription e non Observable .

ConnectableObservable<Long> hot = Observable
                                    .interval(500, TimeUnit.MILLISECONDS)
                                    .publish(); // same as above
Subscription subscription = hot.connect(); // connect returns a subscription object, which we store for further use

hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));
Thread.sleep(1000);
subscription.unsubscribe(); // disconnect, or unsubscribe from subscription

System.out.println("reconnecting");
/* reconnect and redo */
subscription = hot.connect();
hot.subscribe(l -> System.out.println("sub1, " + l));
Thread.sleep(1000);
hot.subscribe(l -> System.out.println("sub2, " + l));
Thread.sleep(1000);
subscription.unsubscribe();

Quanto sopra produce:

sub1, 0   -> subscriber1 starts
sub1, 1
sub1, 2
sub2, 2   -> subscriber2 starts
sub1, 3
sub2, 3
reconnecting  -> reconnect after unsubscribe
sub1, 0
...

Dopo la disconnessione, l' Observable essenzialmente "termina" e si riavvia quando viene aggiunto un nuovo abbonamento.

Hot Observable può essere usato per creare un EventBus . Tali Eventbus sono generalmente leggeri e super veloci. L'unico lato negativo di un RxBus è che tutti gli eventi devono essere implementati manualmente e passati al bus.