RxJava用法详解持续更新中......

1.Observable、Observer、subscribe关系

public void testRxJava(){
        //先创建一个被观察者
        Observable  observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                /*1.ObservableEmitter： Emitter 是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，
                 通过调用emitter的 onNext(T value)、 onComplete()和 onError(Throwable error)。
                 2.请注意，
                被观察者可以发送无限个onNext, 观察者也可以接收无限个onNext.
                当被观察者发送了一个onComplete后, 被观察者onComplete之后的事件将会继续发送, 而观察者收到onComplete事件之后将不再继续接收事件,同理onError也一样
                最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError*/
                e.onNext("a");
            }
        });
        //创建一个观察者
        Observer observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                //dispose方法取消被观察者和观察者的订阅关系
                d.dispose();
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.d("onNext",s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        //被观察者和观察者通过subscribe方法产生订阅关系
        observable.subscribe(observer);
    }

2.Consumer

    @Test
    public void testConsumer(){
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onError(new RuntimeException("is null"));
                //注意onNext方法不要传包装类，否则无法发射到观察者
                e.onNext("a");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                //Consumer的accept()相当于Observer的OnNext()方法,别的事件不关心比如onError
                Log.d("accept",s);
            }
        });
    }

3.Schedulers

 public void testSchedulers(){
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                System.out.println(Thread.currentThread().getName());
                e.onNext("a");
            }
        });
        //1.subscribeOn() 指定的是被观察者发送事件的线程, observeOn() 指定的是观察者接收事件的线程.
        /*2.Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
        Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
        Schedulers.newThread() 代表一个常规的新线程
        AndroidSchedulers.mainThread() 代表Android的主线程*/
        observable.subscribeOn(AndroidSchedulers.mainThread());
        observable.observeOn(Schedulers.newThread());
        Observer observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }
            @Override
            public void onNext(@NonNull String s) {
                System.out.println(Thread.currentThread().getName());
            }
            @Override
            public void onError(@NonNull Throwable e) {

            }
            @Override
            public void onComplete() {

            }
        };
        observable.subscribe(observer);

    }

4.Map

场景： 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢.
很明显, 这是一个嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口.

public void testMap(){
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("a");
               System.out.println("login");
            }
            //map是一个变换操作符, 它的作用就是对被观察者发送的每一个事件都按照指定的函数去变化
        }).map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                s = s+"a";
                System.out.println("register");
                return s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

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

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

5.FlatMap

 Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
        //这里需要注意的是, flatMap并不保证事件的顺序
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("I am value " + integer);
                }
                return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });

6.ConcatMap

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
        }).concatMap(new Function<Integer, ObservableSource<String>>() {
        //和flatMap的作用几乎一模一样, 只是它的结果是严格按照上游发送的顺序来发送的
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("I am value " + integer);
                }
                return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });

7ZIP

public void testZip(){
        Observable observable1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("a");
            }
        });

        Observable observable2 = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(@NonNull ObservableEmitter e) throws Exception {
                e.onNext("b");

            }
        });
        //每发送一个, Zip就组合一个, 再将组合结果发送给Observer.
        Observable.zip(observable1,observable2, new BiFunction<String,String,String>(){
            @Override
            public String apply(@NonNull String s, @NonNull String s2) throws Exception {
                return s+s2;
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onNext(@NonNull Object o) {
                System.out.print(o+"");
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }