RxJava-使用详解与背压原理2

一、RxJava1与RxJava2的区别

前提:RxJava是响应式编程,基于事件流开发。
区别:

  • 1.RxJava2不再支持null值,如果传入一个null会抛出NullPointerException;
  • 2.Observable.just(null)不支持;
  • 3.RxJava2所有的函数接口(Function、Action、Consumer)均设计为可抛出Exception,同时支持自己去解决编译异常需要转化的问题;
  • 4.RxJava2新增的Flowable支持背压模式,即响应事件与接收事件成正比;

二、Flowable和Observable如何选择?

Flowable和Observable都是被观察者,一般处理最大不超过1000条数据,并且几乎不会出现内存溢出,就使用Obervable;
什么时候用Flowable?
1.处理以某种方式产生超过10K的元素;2.文件读取分析,网络IO流;3.有很多阻塞的数据源倒是又想得到一个响应式非阻塞接口。

三、Flowable背压模式的四种处理策略:

1.BackpressureStategy.ERROR:若上游发送事件速度,超出下游处理事件能力,且事件缓存池已满,则抛出异常;
2.BackpressureStrategy.BUFFER:若上游发送事件速度超出下游处理能力,则把事件存储起来等待下游处理;
3.BackpressureStrategy.DROP:若上游发送事件速度超出下游处理能力,事件缓存池满了之后将发送的事件丢弃;
4.BackpressureStrategy.LATEST:若上游发送事件速度超出下游处理能力,则只存储最新的128个事件。

四、操作符

4.1 转换操作符

转换操作符的作用:将事件类型转换成我们需要的结果类型!

4.1.1 map操作符:

map操作符示意图

4.1.2 flatMap操作符:

        /**
         * 使用场景:当app登录前,必须先拿到app的配置
         */
        Observable.just("getConfig", "login").flatMap(new Function>() {
            @Override
            public ObservableSource apply(String s) throws Exception {
                return createResponse(s);
            }

            //**链式调度,串行操作**
            private ObservableSource createResponse(final String s) {
                return Observable.create(new ObservableOnSubscribe() {

                    @Override
                    public void subscribe(ObservableEmitter e) throws Exception {
                        e.onNext("登录 " + s);
                    }
                });
            }
        }).subscribe(
                new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.d(TAG, "onNext: o" + o.toString());
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

4.1.3 GroupBy操作符:

 /*
            比如 一堆书中分为语文书和英语书,现在想要将他们分为两组
         */
        Observable.just(1,2,3,4).groupBy(new Function() {
            @Override
            public String apply(Integer integer) throws Exception {

                return integer > 2 ? "A组":"B组";
            }
        }).subscribe(new Consumer>() {
            @Override
            public void accept(final GroupedObservable stringIntegerGroupedObservable) throws Exception {

                stringIntegerGroupedObservable.subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        String key = stringIntegerGroupedObservable.getKey();
                        Log.d(TAG, "accept: key = " + key + ", integer " + integer);

                    }
                });

            }
        });

程序执行结果:


groupBy调试结果

4.1.4 buffer操作符

/**
         * 适用于大型的数据分组,buffer里面的参数,是每个集合中的元素
         */
        Observable.just(1,2,3,4,5,6).buffer(2).subscribe(new Observer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(List integers) {
                Log.d(TAG, "onNext: " + integers);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

程序执行结果:


buffer操作符调试

4.1.5 scan操作符

/**
         * 比如多个文件合并成一个大文件
         */
        Observable.range(1, 5).scan(new BiFunction() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                //上一个结果作为下一个参数,每次数字与上次结果相加
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

程序执行结果:


scan操作符调试

4.1.6 filter、take、distinct过滤操作符

作用:对多个事件进行过滤

/**
         * 过滤操作符
         * 一堆商品中选出已经过期的商品,其他的不做处理
         */
        Observable.just(1,2,3,4,5,6).filter(new Predicate() {
            @Override
            public boolean test(Integer integer) throws Exception {
                /**
                 * true : 表示事件需要处理
                 */
                return integer > 2;
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {

                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
/**
         * take 过滤操作符
         * 结合interval 做定时器,类似心跳
         */
        Observable.interval(1, TimeUnit.SECONDS)
                //take里面的参数来限制执行的数量
                .take(5)
                .subscribe(new Observer() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d(TAG, "onNext: " + aLong);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
/**
         * distinct操作符过滤掉重复的事件
         */
        Observable.just(1,2,2,3,4,6).distinct().subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {

                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

过程总结:RxJava解决回调地狱,代码可读性高,但是入门有门槛。

4.2 条件操作符

作用:判断所有的事件是不是满足能得到结果的事件(取代for循环判断)

4.2.1 all条件操作符

/**
         * all 条件操作符
         * 
         */
        Observable.just(1,2,3,4,5).all(new Predicate() {
            @Override
            public boolean test(Integer integer) throws Exception {
                //判断是否事件中全部大于2
                return integer > 2;
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG, "accept: " + aBoolean);
            }
        });

4.2.2 contains条件操作符

/**
         * contains
         * 判断被观察者是否包含某一个元素
         */
        Observable.just(1,3,4).contains(3).subscribe(new Consumer() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.d(TAG, "accept: " + aBoolean);
            }
        });

4.2.3 any条件操作符

...此处暂时省略,详情请看demo...

4.3 合并操作符

4.3.1 startWith合并操作符

/**
         * startWith 合并操作符
         * 增加一个新的被观察者
         */
        Observable.just(3,5,6).startWith(Observable.just(7,8,9)).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: integer " + integer);
            }
        });

Demo地址:
https://github.com/cWX411904/RxJavaDemo

你可能感兴趣的:(RxJava-使用详解与背压原理2)