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<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        });

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

//观察者
        Observer<String> reader=new Observer<String>() {
            @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<T> subscribeOn(Scheduler scheduler)

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

public final Observable<T> observeOn(Scheduler scheduler)

线程类型说明如下：

创建操作符

create（）创建一个被观察者

public static <T> Observable<T> create(ObservableOnSubscribe<T> source)

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

public static <T> Observable<T> just(T item) 
......
public static <T> Observable<T> 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 <T> Observable<T> fromArray(T... items)

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

public static <T> Observable<T> fromCallable(Callable<? extends T> supplier)

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

public static <T> Observable<T> fromFuture(Future<? extends T> future)

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

public static <T> Observable<T> fromIterable(Iterable<? extends T> source)

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

public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier)

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

public static Observable<Long> timer(long delay, TimeUnit unit) 

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

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

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

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

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

public static Observable<Integer> range(final int start, final int count)

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

public static Observable<Long> rangeLong(long start, long count)

 empty() & never() & error()

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

never()：不发送任何事件

error()：发送 onError() 事件

public static <T> Observable<T> empty()
public static <T> Observable<T> never()
public static <T> Observable<T> error(final Throwable exception)

public static Observable<Long> timer(long delay, TimeUnit unit)