RXjava 基本模式

自测demo需要准备的pom文件

<!-- https://mvnrepository.com/artifact/org.reactivestreams/reactive-streams -->
<dependency>
    <groupId>org.reactivestreams</groupId>
    <artifactId>reactive-streams</artifactId>
    <version>1.0.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/io.reactivex.rxjava2/rxjava -->
<dependency>
    <groupId>io.reactivex.rxjava2</groupId>
    <artifactId>rxjava</artifactId>
    <version>2.1.12</version>
</dependency>

RXjava的几种模式 Observable Flowable Single Completable Maybe 五种模式

第一种形式 Observerable（被观察者） Observer（观察者）subscribe 进行订阅

package rxjava;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxjavaSchema {

    public static void main(String[] args) {
        Observable<String> observable=Observable.create(observableEmitter->{
            //发射数据方法 每调用一次 发射一次
            observableEmitter.onNext("hihi");
            observableEmitter.onNext("hihi");
            //传递一个完成事件 只会 调用一次，表示不会在调用OnNext方法，即使调用了 也不生效了
            observableEmitter.onComplete();
            //这个数据发射不会生效
            observableEmitter.onNext("hihi");
 //OnNext onError,OnComplete 方法不需要直接推送到最终的观察者， 还可以使用map filter 等操作方法创建新的Observable 然后继续发送
        });

        Observer<String> observer=new Observer<String>() {
            @Override
            //只会调用一次，Disposable 短路处理，针对哪些事件进行丢弃
            public void onSubscribe(Disposable disposable) {
                System.out.println("Observer.onSubscribe");
            }

            @Override
            //针对被观察者发送的数据进行处理
            public void onNext(String s) {
                System.out.println("Observer.onNext: "+s);
            }

            @Override
            //针对被观察者调用的onError方法进行统一处理，只会调用一次
            public void onError(Throwable throwable) {
                System.out.println("Observer.onError");

            }

            @Override
            //针对被观察者发送的onComplete 方法进行处理
            public void onComplete() {
                System.out.println("Observer.onComplete");
            }
        };
        observable.subscribe(observer);
    }
}

Observer.onSubscribe
Observer.onNext: hihi
Observer.onNext: hihi
Observer.onComplete

Flowable模式

//Flowable 支持背压模式
        Flowable.<String>create(observableEmitter->{
            //发射数据方法 每调用一次 发射一次
            observableEmitter.onNext("hihi");
            observableEmitter.onNext("hihi");
            //传递一个完成事件 只会 调用一次，表示不会在调用OnNext方法，即使调用了 也不生效了
            observableEmitter.onComplete();
            //这个数据发射不会生效
            observableEmitter.onNext("hihi");
            //OnNext onError,OnComplete 方法不需要直接推送到最终的观察者， 还可以使用map filter 等操作方法创建新的Observable 然后继续发送
        }, BackpressureStrategy.MISSING).subscribe(new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription subscription) {
                System.out.println("Subscriber.onSubscribe");
            }

            @Override
            public void onNext(String s) {
                System.out.println("Subscriber.onNext "+s);
            }

            @Override
            public void onError(Throwable throwable) {
                System.out.println("Subscriber.onError");
            }

            @Override
            public void onComplete() {
                System.out.println("Subscriber.onComplete");
            }
        });

Subscriber.onSubscribe
Subscriber.onNext hihi
Subscriber.onNext hihi
Subscriber.onComplete

Single模式

//single模式  只有OnSuccess 和 OnError方法
        Single.<String>create(observableEmitter->{
            //，OnSuccess包含了 OnNext和OnCompelete方法  可以发送多次，但是观察者只能消费一次
            observableEmitter.onSuccess("success");
            //不会被观察者消费
            observableEmitter.onSuccess("success");
        }).subscribe(new SingleObserver<String>() {
            @Override
            //只会调用一次 过滤一些case
            public void onSubscribe(Disposable d) {
                System.out.println("SingleObserver.onSubscribe");
            }

            @Override
            public void onSuccess(String s) {
                System.out.println("SingleObserver.onSuccess : "+s);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("SingleObserver.onError");
            }
        });

SingleObserver.onSubscribe
SingleObserver.onSuccess : success

Completable模式

//Completable  不发射数据 只有 onComplete 和 OnError方法
        Completable.create(observableEmitter->{
            observableEmitter.onComplete();
        }).subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("CompletableObserver.onSubscribe");
            }

            @Override
            public void onComplete() {
                System.out.println("CompletableObserver.onComplete");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("CompletableObserver.onError");
            }
        });

CompletableObserver.onSubscribe
CompletableObserver.onComplete

Maybe 模式

//Maybe  是Single和Completable综合实现，0或者1个 发射数据
        //OnSuccess OnError OnComplete
        Maybe.<String>create(observableEmitter->{

            //发射多次 只会有一次生效
            observableEmitter.onSuccess("success");
            //发射数据不生效
            observableEmitter.onSuccess("success");
            //发射完成
            observableEmitter.onComplete();
            //发射数据不生效
            observableEmitter.onSuccess("success");
            //发射数据不生效
            observableEmitter.onSuccess("success");
        }).subscribe(new MaybeObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("MaybeObserver.onSubscribe");
            }

            @Override
            public void onSuccess(String s) {
                System.out.println("MaybeObserver.onSuccess");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("MaybeObserver.onError");
            }

            @Override
            public void onComplete() {
                System.out.println("MaybeObserver.onComplete");
            }
        });

MaybeObserver.onSubscribe
MaybeObserver.onSuccess