Rxjava2使用

概念:

异步数据处理库

特点:

响应式变成,一种基于异步数据流概念的编程模式。
包很小,简洁,功能强大

四个要素

观察者 Observer (Subscriber )
被观察者 Observable
订阅 Subscribe
事件 Event

五大功能模块:

Creating Observable

  • Create 通过以编程方式调用观察者方法从头开始创建一个Observable
  • Defer 在观察者订阅之前不创建Observable,并为每个观察者创建一个新的
  • Empty Never Throw创建具有非常精确和有限的行为的观察
  • From 将其他对象或数据结构转换为Observable(数组、集合)
  • Interval 创建一个Observable,它以一个特定的时间间隔发射一个整数序列 将一个对象或一组对象转换为一个Observable,以发出那个或那些对象(周期发送整数数列)
  • Range 创建一个发射一系列连续整数的Observable
  • Repeat 创建一个可重复发射特定项目或项目序列的Observable
  • Start 创建一个可以发出函数返回值的Observable
  • Timer 创建一个Observable,在给定的延迟后发出一个单一的项目
Rxjava2使用_第1张图片
Create
Rxjava2使用_第2张图片
From
Rxjava2使用_第3张图片
Interval

Transforming Observable

  • Buffer定期从一个Observable中收集物品成束,然后发射这些包,而不是一次发射一个物品
  • FlatMap 将Observable发射的物体转化为Observable,然后将这些物体的辐射平均化为一个Observable
  • GroupBy 将Observable分成一组Observable,每个Observable从原始的Observable发出不同组的项目,按键组织
  • Map 通过对每个项目应用一个函数来转换Observable发出的项目
  • Scan 对由Observable发出的每个项目按顺序应用一个函数,并发出每个连续的值
  • Window 周期性地将Observable中的物品细分为Observable窗口并发出这些窗口,而不是一次一个地发射物品

Map和FlatMap区别
两者都能实现同样的功能,区别在于表达形式

 Observable.just("just", "hello", "girl", "1", "2", "3").buffer(2).subscribe(
                new Subscriber>() {
                    @Override
                    public void onCompleted() {
                        System.out.print("____________________________________________onCompleted \n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.print(e.getMessage() + "______________onError \n");
                    }

                    @Override
                    public void onNext(List s) {
                        for (int i = 0; i < s.size(); i++) {
                            System.out.print(s.get(i) + " ");
                        }
                        System.out.print("______________onNext \n");
                    }
                });
 Observable.just(student1, student2, student2)
                //使用map进行转换,参数1:转换前的类型,参数2:转换后的类型
                .map(new Func1() {
                    @Override
                    public String call(Student i) {
                        String name = i.name;//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1() {
                    @Override
                    public void call(String s) {
                        System.out.print(s + "______________onNext \n");
                    }
                });

Filtering Observable

  • Debounce 如果特定的时间间隔已经过去,而没有发射另一个物品,则只从Observable发射一个物品(超过这个时间段且没有创建操作才会发射)
  • Distinct 抑制Observable发出的重复项目
  • ElementAt发射Observable发出的物品
  • Filter 仅从通过测试的Observable发出这些项目
  • First 仅从Observable中发射第一个项目或符合条件的第一个项目
  • IgnoreElements 不要从Observable发射任何项目,但要镜像终止通知(走onCompleted或onError,不走onNext)
  • Last 只发出Observable发出的最后一个项目
  • Sample 在周期性时间间隔内发出Observable发出的最近的项目
  • Skip压制(跳过)Observable发出的前项目
  • SkipLast压制(跳过)Observable发出的最后n个项目
  • Take 只发射Observable发出的前物品
  • TakeLast 只发出Observable发出的最后n个项目
  Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                try {
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(2000);
                        subscriber.onNext(i + "");
                    }
                    subscriber.onCompleted();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).debounce(1, TimeUnit.SECONDS).subscribe(
                new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.print("____________________________________________onCompleted \n");
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.print(e.getMessage() + "______________onError \n");
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.print(s + "______________onNext \n");
                    }
                });
Observable.just("just", "hello", "girl", "just").elementAt(2).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.print("____________________________________________onCompleted \n");
            }

            @Override
            public void onError(Throwable e) {
                System.out.print(e.getMessage() + "______________onError \n");
            }

            @Override
            public void onNext(String s) {
                System.out.print(s + "______________onNext \n");
            }
        });
  Observable.just("just", "hello", "girl", "just").ignoreElements().subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.print("____________________________________________onCompleted \n");
            }

            @Override
            public void onError(Throwable e) {
                System.out.print(e.getMessage() + "______________onError \n");
            }

            @Override
            public void onNext(String s) {
                System.out.print(s + "______________onNext \n");
            }
        });

Combining Observable

  • And 通过两种或两种以上的可观察物体和中间物体组合物品
  • CombineLatest 当两个Observable发射一个物体时,通过指定的函数合并每个Observable发射的最新物体,并根据这个函数的结果发射物体
  • Join 当一个Observable中的某个项目在根据另一个Observable发出的项目定义的时间窗口内发射时,将两个Observable发射的项目组合起来
  • Merge 通过合并排放,将多个观测器合并为一个
  • StartWith 在开始从源Observable发射项目之前,发射指定的项目序列(first插入observable)
  • Switch 将一个Observable转换成一个Observable,这个Observable发射这些Obserbles中最近发射的物品
  • Zip 通过指定的函数将多个Observable的发射结合在一起,并基于这个函数的结果为每个组合发射单个项目
 Observable just = Observable.just(1, 2);
        Observable just2 = Observable.just("just", "hello", "girl");
        just.join(just2, new Func1>() {
            @Override
            public Observable call(Integer integer) {
                return Observable.timer(1, TimeUnit.SECONDS);
            }
        }, new Func1>() {
            @Override
            public Observable call(String s) {
                return Observable.timer(2, TimeUnit.SECONDS);
            }
        }, new Func2() {
            @Override
            public String call(Integer integer, String s) {
                return integer + "_____" + s;
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.print("____________________________________________onCompleted \n");
            }

            @Override
            public void onError(Throwable e) {
                System.out.print(e.getMessage() + "______________onError \n");
            }

            @Override
            public void onNext(String s) {
                System.out.print(s + "______________onNext \n");
            }
        });
 Observable just = Observable.just(1, 2, 3);
        Observable just2 = Observable.just("just", "hello", "girl", "just");
        Observable.zip(just, just2, new Func2() {
            @Override
            public String call(Integer s, String s2) {
                return s + "___" + s2;
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.print("____________________________________________onCompleted \n");
            }

            @Override
            public void onError(Throwable e) {
                System.out.print(e.getMessage() + "______________onError \n");
            }

            @Override
            public void onNext(String s) {
                System.out.print(s + "______________onNext \n");
            }
        });

Error Handling Observable

  • CatchonError通过继续顺序没有错误恢复
  • Retry如果一个源Observable发送一个通知,重新订阅它,希望它会没有错误地完成

Scheduler(调度器)

Schedulers.immediate(): 直接在当前线程运行,相当于不指定线程。这是默认的 Scheduler。
Schedulers.newThread(): 总是启用新线程,并在新线程执行操作。
Schedulers.io(): I/O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。行为模式和 newThread() 差不多,区别在于 io() 的内部实现是是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中,可以避免创建不必要的线程。
Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算,即不会被 I/O 等操作限制性能的操作,例如图形的计算。这个 Scheduler 使用的固定的线程池,大小为 CPU 核数。不要把 I/O 操作放在 computation() 中,否则 I/O 操作的等待时间会浪费 CPU。
另外, Android 还有一个专用的 AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。

全部示例下载

参考:

官方文档
给 Android 开发者的 RxJava 详解(Rxjava1)

你可能感兴趣的:(Rxjava2使用)