RxJava 学习笔记(1)

 

创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。指定被观察者的线程，要注意的时，如果多次调用此方法，只有第一次有效。RxJava的Git地址

https://github.com/ReactiveX/RxAndroid

什么是RxJava

响应式编程的一个实现

什么是编程范式？

编程是为了解决问题，而解决问题可以有多种视角和思路，其中具有普适性的模式被归结为范式。我们常说的：“面向对象”，“面向过程”都是编程范式。

什么是响应式编程

专注于数据流和变化传递的异步编程范式，响应式编程，本质上是对数据流或某种变化所作出的反应，但是这个变化什么时候发生是未知的，所以他是一种基于异步、回调的方式在处理问题。

什么是同步和非同步、阻塞和非阻塞

同步：是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去

异步：是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。

同步和异步关注的是消息通信机制

阻塞调用：是指调用结果返回之前，当前线程会被挂起。一直处于等待消息通知，不能够执行其他业务，调用线程只有在得到结果之后才会返回。

非阻塞调用：指在不能立刻得到结果之前，该调用不会阻塞当前线程，而会立刻返回。

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态

一般异步是配合非阻塞使用的，这样才能发挥异步的效用。

RxJava基于观察者模式实现的

假设场景：A是连载小说，B是读者，读者订阅了连载小说，当小说出现了新的连载的时候，会推送给读者。读者不用时刻盯着小说连载，而小说有了新的连载会主动推送给读者。

RxJava demo （基于RxJava2）

配置：

implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'io.reactivex.rxjava2:rxjava:2.2.11'

第一步：创建被观察者（创建小说-，其中小说就是对应的事件流）

//被观察者
        Observable novel=Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        });

第二步：创建观察者（）读者

//观察者
        Observer reader=new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                mDisposable=d;
                Log.e(TAG,"onSubscribe");
            }

            @Override
            public void onNext(String value) {
                if ("2".equals(value)){
                    mDisposable.dispose();
                    return;
                }
                Log.e(TAG,"onNext:"+value);
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG,"onError="+e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e(TAG,"onComplete()");
            }
        };

第三步：建立订阅关系

novel.subscribe(reader);//一行代码搞定

RxJava进阶

https://juejin.im/post/5b17560e6fb9a01e2862246f

对于一个事件流，可能需要对其进行一系列操作变换之后再发送给订阅者，这个中间的处理过程就叫做变换，RxJava的操作符介绍如下

线程切换

指定被观察者的线程，要注意的时，如果多次调用此方法，只有第一次有效。

public final Observable subscribeOn(Scheduler scheduler)

指定观察者的线程，每指定一次就会生效一次。 

public final Observable observeOn(Scheduler scheduler)

线程类型说明如下：

创建操作符

create（）创建一个被观察者

public static  Observable create(ObservableOnSubscribe source)

 just（）创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。

public static  Observable just(T item) 
......
public static  Observable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)

 fromArray() 这个方法和 just() 类似，只不过 fromArray 可以传入多于10个的变量，并且可以传入一个数组。

public static  Observable fromArray(T... items)

fromCallable() 这里的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它会返回一个结果值，这个结果值就是发给观察者的。

public static  Observable fromCallable(Callable supplier)

fromFuture()参数中的 Future 是 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，它可以通过 get() 方法来获取Callable 返回的值。

public static  Observable fromFuture(Future future)

fromIterable()直接发送一个 List 集合数据给观察者

public static  Observable fromIterable(Iterable source)

defer()这个方法的作用就是直到被观察者被订阅后才会创建被观察者

public static  Observable defer(Callable> supplier)

timer()当到指定时间后就会发送一个 0L 的值给观察者

public static Observable timer(long delay, TimeUnit unit) 

interval()每隔一段时间就会发送一个事件，这个事件是从0开始，不断增1的数字。

public static Observable interval(long period, TimeUnit unit)
public static Observable interval(long initialDelay, long period, TimeUnit unit)

 intervalRange()可以指定发送事件的开始值和数量，其他与 interval() 的功能一样。

public static Observable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
public static Observable intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

range()同时发送一定范围的事件序列。

public static Observable range(final int start, final int count)

 rangeLong()作用与 range() 一样，只是数据类型为 Long

public static Observable rangeLong(long start, long count)

 empty() & never() & error()

empty() ： 直接发送 onComplete() 事件

never()：不发送任何事件

error()：发送 onError() 事件

public static  Observable empty()
public static  Observable never()
public static  Observable error(final Throwable exception)

public static Observable timer(long delay, TimeUnit unit)