RxJava一些创建操作符的基本使用

最新推荐文章于 2024-10-16 17:45:37 发布

后知i

最新推荐文章于 2024-10-16 17:45:37 发布

阅读量61

点赞数

文章标签： rxjava android

本文链接：https://blog.csdn.net/weixin_51457574/article/details/132643231

版权

create

使用create操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数。

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {

        try {
        //建议先检查一下观察者的isDisposed状态，以便在没有观察者的时候，让Observable停止发射数据，防止运行昂贵的运算
            if (!emitter.isDisposed()) {
                emitter.onNext("hello create");
            }
            emitter.onComplete();
        }catch (Exception e) {
            emitter.onError(e);
        }
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        System.out.println("next = "+s);
    }
}, new Consumer<Throwable>() {
    @Override
    public void accept(Throwable throwable) throws Exception {
        System.out.println("error = "+throwable);
    }
}, new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("create complete");
    }
});

just

创建一个发射指定值的Observable。将单个数据转换为发射这个单个数据的Observable。
它可以接受一至十个参数，返回一个按参数列表顺序发射这些数据的Observable。

Observable.just("hello just")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });

from

from可以将其他种类的对象和数据类型转换为Observable。比如Future、Iterable和数组转换成Observable。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。

Observable.fromArray("hello","from")
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });

ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> future = executorService.submit(new MyCallable());
//from方法可以接受两个可选参数，分别指定超时时长和时间单位。如果过了指定时长，Future还没有返回一个值，那么这个Observable就会发射错误通知并终止。
Observable.fromFuture(future,4, TimeUnit.SECONDS)
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {

            }
        });
//输出结果
//模拟一些耗时的任务...
// io.reactivex.exceptions.OnErrorNotImplementedException 执行结果报错，说明超时的设置起了作用


 class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("模拟一些耗时的任务....");
        Thread.sleep(5000);
        return "OK";
    }
}

repeat

创建一个发射特定数据重复多次的Observable。

Observable.just("hello repeat")
        .repeat(3)
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println("s = "+s);
            }
        });
//执行结果
//s = hello repeat
//s = hello repeat
//s = hello repeat

repeatWhen

repeatWhen不是缓存和重放原始Observable的数据序列，而是有条件地重新订阅和发射原来的Observable。

repeatUtil

直到某个条件就不再重复发射数据。当BooleanSupplier的getAsBoolean()返回false时，表示重复发射上游的Observable；当getAsBoolean()为true时，表示中止重复发射上游的Observable。

final long startTime = System.currentTimeMillis();
Observable.interval(500,TimeUnit.MICROSECONDS)
        .take(5)
        .repeatUntil(new BooleanSupplier() {
            @Override
            public boolean getAsBoolean() throws Exception {
                return System.currentTimeMillis()-startTime > 5000;
            }
        }).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                System.out.println(aLong);
            }
        });

defer

直到有观察者订阅时才创建Observable，并且为每个观察者创建一个全新的Observable。

Observable observable = Observable.defer(new Callable<ObservableSource<?>>() {
    @Override
    public ObservableSource<?> call() throws Exception {
        return Observable.just("hello defer");
    }
});
observable.subscribe(new Consumer<String>() {

    @Override
    public void accept(String s) throws Exception {
        System.out.println(s);
    }
});