Rxjava基本介绍

一,作用

       RxJava的目的就是异步。RxJava的特点就是可以非常简便的实现异步调用，可以在逻辑复杂的代码逻辑中以比较轻易的方式实现异步调用。随着逻辑的复杂，需求的更改，代码可依然能保持极强的阅读性.

二,添加依赖

    io.reactivex.rxjava2:rxjava:2.0.4

 

    io.reactivex.rxjava2:rxjava:2.0.4

 

 

 

三,关键API

       1,Observable：在观察者模式中称为“被观察者”；

 

      2,Observer：观察者模式中的“观察者”，可接收Observable发送的数据； 

 

      3,subscribe：订阅，观察者与被观察者，通过subscribe()方法进行订阅； 

      4,Subscriber：也是一种观察者，在2.0中 它与Observer没什么实质的区别，不同的是 Subscriber要与Flowable(也是一种被观察者)联合使用，该部分内容是2.0新增的，后续文章再介绍。Obsesrver用于订阅Observable，而Subscriber用于订阅Flowable

                                      

 

 

四,回调方法
 

     1,onComplete():事件队列完结时调用该方法。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。

     2,onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。  

     3,onSubscribe()：RxJava 2.0 中新增的，传递参数为Disposable ，Disposable 相当于RxJava1.x中的Subscription,用于解除订阅。  注意：onComplete() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

 

五,线程调度,Scheduler，

  相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。

        1,Schedulers.immediate():直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。

        2,Schedulers.newThread(): 总是启用新线程，并在新线程执行操作

      3,Schedulers.io():I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler,多数情况下 io() 比 newThread() 更有效率

       4,Schedulers.computation():计算所使用的 Scheduler,不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。

       5,Android 还有一个专用的** **AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
 

       6,subscribeOn(): 指定Observable(被观察者)所在的线程，或者叫做事件产生的线程。

       7,observeOn(): 指定 Observer(观察者)所运行在的线程，或者叫做事件消费的线程。

 

     8,Disposable**, 这个单词的字面意思是一次性用品,用完即可丢弃的。在RxJava中,用它来切断Observer(观察者)与Observable(被观察者)之间的连接，当调用它的dispose()方法时, 它就会将Observer(观察者)与Observable(被观察者)之间的连接切断, 从而导致Observer(观察者)收不到事件。

 

六,代码
 //第二种方式,采用链式调用
    private void second() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("hello world");
                e.onNext("第一次用");
                e.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(String s) {
                Log.e(TAG, s);
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "onComplete");
            }
        });
    }

  
    //第三种方式,使用Consumer只接收发送信息
    private void third() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("hello world");
                e.onNext("第一次用");
                e.onComplete();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                //表示我只在乎next发出的消息,也只接受这个消息
                Log.e(TAG, s);
            }
        });
    }

   //第四种,调用Schedulers线程调度器
    private void four() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Log.e(TAG, "事件产生线程" + Thread.currentThread().getName());
                e.onNext("hehe");

            }
        }).subscribeOn(Schedulers.io()) //事件产生的线程,也就是被观察者
                .observeOn(AndroidSchedulers.mainThread()) //时间消费的线程,也就是观察者
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.e(TAG, "接受到的结果" + s);
                        Log.e(TAG, "事件消费线程" + Thread.currentThread().getName());
                    }
                });
    }



     / *第五种,使用just直接出发onNext()
       * 使用just( )，将为你创建一个Observable并自动为你调用onNext( )发射数据。
       * 通过just( )方式 直接触发onNext()，just中传递的参数将直接在Observer的onNext()方法中接收到。*/

  //1,just是专门用来发射单条数据的，可以是一个数据，一条字符，一个对象，一整个数组，一整个集合。

 //2,Consumer可以看做是对观察者Observer功能单一化之后的产物——消费者，上例中的Consumer通过其函数accept只接收

//可观察对象发射的数据，不接收异常信息或完成信息。
    private void five() {
        Observable.just("hello").subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, s);
            }
        });
    }



   //第六种,使用interval做定时器,
    private void six() {
        //可用作定时器。即按照固定2秒一次调用onNext()方法。
        Observable<Long> observable = Observable.interval(2, TimeUnit.SECONDS);
        Observer<Long> observer = new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Long aLong) {
                Log.e(TAG, aLong.toString());
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {

            }
        };
        SystemClock.sleep(6000);//睡眠6秒后，才进行订阅, 仍然从0开始，表示Observable内部逻辑刚开始执行
        observable.subscribe(observer);

    }

 

   //第七种,使用map将一种数据转换成另一种数据返回
    private void seven() {
        Observable.just("hello").map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) throws Exception {
                return s.length();
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.e(TAG, "返回的数据 " + integer);
            }
        });
    }

  
   //第八种,使用filter将需要的数据筛选出来
    private void eight() {
        lists.add("你好呵呵呵呵呵");
        lists.add("开心哈哈哈哈");
        Observable.just(lists).flatMap(new Function<List<String>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(List<String> strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).filter(new Predicate<Object>() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.charAt(5) - '0' > 5) {
                    return true;
                }
                return false;
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                System.out.println((String) o);
                Log.e(TAG, "返回的数据 " + (String) o);
            }
        });
    }

   
    // 第九种,使用Flowable处理背压问题(所谓背压，即生产者的速度大于消费者的速度带来的问题
  
    private void nine() {
        Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                Log.e(TAG, "我是1");
                emitter.onNext(1);
                Log.e(TAG, "我是 2");
                emitter.onNext(2);
                Log.e(TAG, "我是 3");
                emitter.onNext(3);
                Log.e(TAG, "我是 complete");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR); //增加了一个参数

        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.e(TAG, "onSubscribe");
                s.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "onError: ", t);
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "onComplete");
            }
        };
        flowable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(subscriber);
    }






      /*
       //第十种点击“开始”按钮，建立连接。生产者开始生产事件，刚开始消费者通过request()只要了50个事件消费。
       // 然后每次点击“消费”按钮，再次消费50个事件。
       * 可以看出，生产者一次性传入128个事件进入缓存池。点击“开始”按钮，消费了50个。
       * 然后第一次点击“消费”按钮，又消费了50个，第二次点击“消费”按钮，再次消费50个。
       * 然而此时原来的128个缓存只剩下28个了，所以先消费掉28个，

       * 然后剩下22个是后来传入的（其实后来的是在消费了96个后传入，并一次性在缓存池中又传入了96个）。*/

 

    private void ten() {
        mFlowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0;i< 300 ; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.DROP);

        mSubscriber = new Subscriber<Integer>() {
            @Override
            public void onSubscribe(Subscription s) {
                mSubscription = s;
                s.request(50);
            }

            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "onError: "+t);
            }

            @Override
            public void onComplete() {
                Log.e(TAG, "onComplete: ");
            }
        };
    }

    public void consume() {
        mFlowable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(mSubscriber);
    }

    public void consumeAgain() {
        mSubscription.request(50);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.consume:
                consume();
                break;
            case R.id.consume_again:
                consumeAgain();
                break;
        }
    }