RXJava入门02

最新推荐文章于 2024-09-30 15:37:45 发布

piziliul

最新推荐文章于 2024-09-30 15:37:45 发布

阅读量194

点赞数 1

分类专栏： RXJava 文章标签： RXJava android RXJava被观察者的创建方式

本文链接：https://blog.csdn.net/piziliul/article/details/77620239

版权

RXJava 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

RXJava被观察者的创建操作

Craeat

Craeat操作符从头开始创建一个Observable,并在恰当的时候调用观察者的onNext(),onError和onCompleted方法。
使用Observable时必须调用观察者的onCompleted正或者onError一次作为结束
在create方法中检查观察者的isUnsubscribed状态，以便在没有观察者的时候，让Observable停止发射数据。

Creat的使用代码如下

// 最完整的创建方法
    public static void test1() {

        Observable.// 创建被观察者
                create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                // 如果当前的观察者已经订阅了
                if (!subscriber.isUnsubscribed()) {
                    for (int i = 0; i < 5; i++) {
                        // 发送数据
                        subscriber.onNext(i);
                    }
                    //---->如果没有订阅,就不会发送消息
                    // 正常结束的时候调用onCompleted()进行结束
                    // 发送完毕
                    subscriber.onCompleted();
                }
            }
        }).// 订阅 关联
                subscribe(new Observer<Integer>() { // 创建观察者
            @Override
            public void onCompleted() {
                Log.e("TAG", "onCompleted");
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(Integer integer) {
                Log.e("TAG", "onNext" + integer);
            }
        });
    }

Defer

创建一个个返回Observable的Observable。该特殊的Observable在观察者订阅他的时候，会调用内部的call方法，并返回一个实用的Observable与观察者关联

Defer 的使用代码如下

//defer 创建一个延迟的被观察者
    public static void test2() {
        // defer方法创建的被观察者实际上没有作用,它是在订阅的时候,在内部创建一个新被观察者供订阅者进行关联
        // 每关联一个观察者对象,那么特殊的被观察者内部就会创建多一个被观察者供关联
        Observable<Integer> observable = Observable.defer(new Func0<Observable<Integer>>() {
            @Override
            public Observable<Integer> call() {
                Observable<Integer> observable1 = Observable.create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(1);
                    }
                });
                Log.e("TAG", "call:");
                return null;
            }
        });
        observable.subscribe(new Action1<Integer>() {
            // 订阅了onNext()事件
            @Override
            public void call(Integer integer) {

            }
        });
        observable.subscribe(new Action1<Integer>() {
            // 订阅了onNext()事件
            @Override
            public void call(Integer integer) {

            }
        });
    }

Just

可以同时发送多条数据(最多九条),数据发送结束的时候自动调用onCompleted()方法

just的使用代码如下

// just 替代原始的create方法
    public static void test3() {
        Observable
//                .create(new Observable.OnSubscribe<String>() {
//            @Override
//            public void call(Subscriber<? super String> subscriber) {
//                if (!subscriber.isUnsubscribed()) {
//                    subscriber.onNext("人丑就要多读书");
//                    subscriber.onNext("精通安卓必成高富帅");
//                    subscriber.onCompleted();
//                }
//            }
//        })
                .just("人丑就要多读书", "精通安卓必成高富帅")// 当所有的事件发送完成之后会自动调用onCompleted();
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("TAG", "call:" + s);
                    }
                });
    }

From

操作队列的From方法,from函数可以发送一个队列的数据,输入的长度无限

from的使用代码如下

 // from 操作队列
    public static void test4() {
        // 学生点名案例
//        ArrayList students = initStudents();
//        for (int i = 0; i < students.size(); i++) {
//            Log.e("TAG", "test4()"+students.get(i));
//        }
        Observable.from(initStudents())// 发送了队列里面的
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        Log.e("TAG", "call:" + o);
                    }
                });
    }

interval &timer 类似于定时器的功能

类定时器Interval&Timer,可以代替Timer使用,interval它接受一个表示时间间隔的参数和一个表示时间单位的参数

interval和timer的简单使用代码如下

//interval &timer 类似于定时器的功能
    public static void test5() {
//        new Timer().schedule(new TimerTask() {
//            @Override
//            public void run() {
//                Log.e("TAG", "run"+Thread.currentThread().getName());
//            }
//        },3000,3000);
        // 一下两种方法 实际上就是定时器的功能
//        Observable
//                .interval(3, TimeUnit.SECONDS, Schedulers.io())
//                .subscribe(new Action1<Long>() {
//                    @Override
//                    public void call(Long aLong) {
//                        Log.e("TAG", "call :" + Thread.currentThread().getName());
//                    }
//                });
        Observable
                .timer(3, TimeUnit.SECONDS, Schedulers.io())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {//aLong 表示执行的次数
                        Log.e("TAG", "call :" + Thread.currentThread().getName());
                    }
                });
    }

数字操作Range&重复操作Repeat

range可以指定发送一个数据范围内的数据,repeat重复发送数据

range和repeat的使用代码如下

 public static void test6() {
//        // 从1数到10
//        for (int i = 0; i < 11; i++) {
//            Log.e("TAG", "test6"+i);
//        }
        // 遍历
//        Observable
//                .range(1,10)// 指定发送一个数据范围的数据
//                .subscribe(new Action1<Integer>() {
//                    @Override
//                    public void call(Integer integer) {
//                        Log.e("TAG", "call:"+integer );//1,2,3,4,5,6,7,8,9,10
//                    }
//                });
        // 重复
        Observable
                .just("人丑就要多读书")
                .repeat(3)// 将被观察者发送的数据重复发送
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String string) {
                        Log.e("TAG", "call:" + string);
                    }
                });

    }

延迟操作代码Delay

Delay操作符让原始Observable在发射每项数据之前都暂停一段指定的时间段。效果是Observable发射的数据项在时间上向前整体平移了一个增量

delay使用代码如下

public static void test7() {
        Observable.just("起床", "洗脸", "刷牙")
                .delay(3, TimeUnit.SECONDS)// 让被观察者发送的数据整体延迟3s
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("TAG", "call: " + s);
                    }
                });
    }