Rxjava2.0 之第一篇

rxjava 的GitHub地址：https://github.com/ReactiveX/RxJava

RXJava是反应式扩展的Java VM实现：一个用于使用可观察序列组成异步和基于事件的程序的库。

它扩展了观察者模式以支持数据/事件的序列，并添加了操作符，允许您声明性地将序列组合在一起，同时抽象出对诸如低级线程、同步、线程安全和并发数据结构等问题的关注。

1.0版本是截至2018年3月31日的终生。没有进一步的开发，支持，维护，PRS和更新将发生。最后版本1.3.8的JavaDoc将仍然是可访问的。

2.0版本特性：
单一依赖性：反应流
继续支持Java 6+ ，Android 2.3+
通过1.x周期和通过无功流共享项目学习的设计更改获得性能增益。
Java 8 LAMBDA API
对并发源（线程、池、事件循环、纤维、行动者等）
异步或同步执行
用于参数化并发的虚拟时间和调度程序

版本2.0和1.0将并肩共存数年。它们具有不同的组ID（io.reactivex.rxjava2 vs io.reactivex）和命名空间（io.reactivex vs ）。
查看1版本和2版本之间的差异，请查看地址 https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0

刚开始的时候我也是小白一员，感觉rxjava比较难，可是实战后你会发现，rxjava竟然这么可爱，辅助你完成很多工作，代码这玩意不能看，光看你这辈子都是门外汉，动手多练习几遍，你会发现原来也就这么回事，已经站在巨人的肩膀上做事了，所以。。。

一、rxjava2.0 相对于1.0来说，更新中出现了两种观察者模式

Observable(被观察者)/Observer(观察者)，然而它不支持背压

Flowable (被观察者)______subscribe(订阅)____----->Subscriber(观察者)，支持背压

二、常用到的操作符

map图> 通过将一个函数应用到每个项来转换可观察到的项

zip 邮编- > 通过指定的函数组合多个观测值的排放量，并根据此函数的结果为每个组合发出单个项。

Filter 过滤器- > 仅通过通过谓词测试的可见对象发出这些项。

flatmap -> 将可观察到的项目转换为观测值，然后将这些排放量变为单一观测值。

Take带-> 只发出观察到的第一个n个项。

Reduce 减少-> 将函数应用于可见的、顺序的、并发出最终值的每个项目。

Skip 跳过-> 抑制观察到的第一个n个项。

Buffer 缓冲- > 定期收集由可观察到的包发出的项，并发出这些束，而不是一次一个地输出这些项。

Concat 连接两个字符串-> 从两个或两个以上的观测值中发射，而无需交错它们。

Replay 重播> 确保所有观察者看到相同的已发布项目序列，即使它们在已观察到已开始发布项目之后订阅。

Merge 合并- > 合并多个观测值合并成一个排放量

三、示例

3.1

Observable.create(new ObservableOnSubscribe<String>() { //Observable.create 是创建被观察者，
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        e.onNext("123");  //ObservableEmitter 是发射器，向下游发射数据
        e.onNext("456");
        e.onNext("789");
    }
}).subscribe(new Observer<String>() { //subscribe 订阅观察者，说法有点别扭，所以，现在统称接收器
    private Disposable disposable;
    private String string;
    /**
     * 用于解除订阅
     * @param d
     */
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        disposable = d;
    }

    @Override
    public void onNext(@NonNull String string) {
        Log.e("---->", string);
        textView.setText(string);
        if (string.equals("456")) {
            disposable.dispose(); //当上游条件满足某个条件的时候，解除订阅关系
        }
    }

    @Override
    public void onError(@NonNull Throwable e) {
        e.printStackTrace();
    }
	//注意了，onError 和 onComplete 方法是只会有一个执行，不管是哪个方法执行了，当前的订阅关系都解除终止了  
    @Override
    public void onComplete() {
        Log.e("--->", "完成");
    }
});

3.2

Observable.create((e) -> {  //此处使用了lambda表达式
        e.onNext(999);
        e.onNext(9996);
        e.onNext(999666);

    //subscribeOn 用于指定 subscribe() 时所发生的线程
}).subscribeOn(Schedulers.newThread()) //总是启用新线程，并在新线程执行操作。
        .subscribeOn(Schedulers.io()) //（注意，本次指定io线程无效）指定 subscribe() 事件发送发生在 IO 线程；Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作；
        .observeOn(AndroidSchedulers.mainThread()) //指定下游Subscriber 的回调处理发生在主线程, 指定的操作将在 Android 主线程运行
        .doOnNext(new Consumer() {
            @Override   //接收
            public void accept(@NonNull Object integer) throws Exception {
                textView2.setText(integer+"--main--"+Thread.currentThread().getName());
                Log.e("-->>", (Integer.valueOf(integer.toString())) + "----"+Thread.currentThread().getName());
                Schedulers.io().createWorker().schedule(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(2000);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        })
        .observeOn(Schedulers.io()) //指定io流线程
.subscribe(new Consumer<Integer>() { //Consumer 即消费者，用于接收单个值，BiConsumer 则是接收两个值，
                                    // Function 用于变换对象，Predicate 用于判断
    @Override
    public void accept(Integer integer) throws Exception {
        textView.setText(integer + "--io--"+Thread.currentThread().getName());
        Log.e("----2----->>", integer + "----"+Thread.currentThread().getName());
    }
});

该文为基本使用，后面会接着写完这几个操作符，有问题请指出，我也在学习阶段

猜你喜欢