android rxjava 2.x 框架性学习

android rxjava 2.x 框架性学习

RxJava
是一个Java虚拟机实现的有效扩展框架：用于通过使用观察序列构成异步和基于事件编程的程序库
它扩展了观察者模式，以支持数据/事件序列，通过增加操作符，将序列清晰的组合在一起的。
这些序列组合可以是抽象出来的某些数据/事件，如低级别的线程，同步，线程安全和并发数据结构。
它是一种响应式编程库。

RxJava实现策略：
通过扩展的观察者模式，异步实现（不同线程间）Observable的事件序列的发送，Observer接收、处理事件
事件序列：
可以是诸如网络访问、数据库操作、文件读取、按键、List遍历等事件类型

RxJava框架核心：
1、扩展的观察者模式
Observable/Flowable(支持Backpressure背压，Backpressure策略仅是处理Subscriber接收事件的方式，2.x中添加Flowable支持背压，Observable设计成非背压) (被观察者)
Observer/Subscriber (观察者)
subscribe (订阅)
event（事件)
Observable和Observer通过 subscribe()方法实现订阅关系，Observable可以在需要的时候发出事件来通知 Observer

常用观察者模式：
Observable/Observer
Flowable/Subscriber
Single/SingleObserver
Completable/CompletableObserver
Maybe/MaybeObserver

观察者：
Observer、Subscriber、SingleObserver、MaybeObserver、CompletableObserver

public interface Observer<T> {
    void onSubscribe(Disposable d);
    void onNext(T t);
    void onError(Throwable e);
    void onComplete();
}
public interface Subscriber<T> {
    public void onSubscribe(Subscription s);
    public void onNext(T t);
    public void onError(Throwable t);
    public void onComplete();
}
interface SingleObserver<T> { //遵循协议 onSubscribe (onSuccess | onError)
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
}
public interface MaybeObserver<T> { //遵循协议:onSubscribe(onSuccess | onError | onComplete)
    void onSubscribe(Disposable d);
    void onSuccess(T t);
    void onError(Throwable e);
    void onComplete();
}
public interface CompletableObserver { //遵循协议 onSubscribe (onComplete | onError)
    void onSubscribe(Disposable d);
    void onComplete();
    void onError(Throwable e);
}

DefaultSubscriber：
public abstract class DefaultSubscriber<T> implements FlowableSubscriber<T>
//通过实现Subscriber接口，可以通过调用request(long n)方法请求或者cancel()方法取消订阅（同步请求）

DisposableSubscriber：
public abstract class DisposableSubscriber<T> implements FlowableSubscriber<T>, Disposable
//通过实现Desposable异步删除。

ResourceSubscriber：
public abstract class ResourceSubscriber<T> implements FlowableSubscriber<T>, Disposable 
//允许异步取消其订阅相关资源，节省内存而且是线程安全。

SafeSubscriber：
public final class SafeSubscriber<T> implements FlowableSubscriber<T>, Subscription
//包装另一个订阅者,并确保所有onXXX方法遵守协议(序列化要求访问除外)。

SerializedSubscriber：
public final class SerializedSubscriber<T> implements Subscriber<T>, Subscription
//序列化访问另一个订阅者的onNext,onError和onComplete方法。

Observable创建方式：
1、

Observable.create()方式：
Observable<Integer>  observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        ...
        emitter.onComplete();
    }
});
//java1.8 语法形式
Observable<Object> source = Observable.create((ObservableEmitter<Object> emitter) -> {
    emitter.onNext(1);
    ...
    emitter.onComplete();
});
source.subscribe(e -> { /* Ignored. */ }, Throwable::printStackTrace);

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
     @Override
     public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
         emitter.onNext(1);
         ...
         emitter.onComplete();
     }
}, BackpressureStrategy.ERROR);

2、
just()方式

Observable<String> observable = Observable.just("Hello");

使用just()创建一个Observable并自动为调用onNext()发射数据。just()中传递的参数将直接在Observer的onNext()方法中接收到
3、

fromIterable()方式（fromArray,fromIterable,fromFuture）:
List<String> list = new ArrayList<String>();
for(int i =0;i<10;i++){
   list.add("number "+i);
}
Observable<String> observable = Observable.fromIterable((Iterable<String>) list);
//fromIterable()遍历集合，发送每个item，每个item对应一次onNext()方法调用。

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(1);
list.add(5);
Flowable.fromIterable(list)
        .subscribe(num -> System.out.println(num));
Flowable.fromArray(1, 0, 6)
        .filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer.intValue() > 5;
            }
        })
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println(integer);
            }
        });    

注意：
Collection接口是Iterable接口的子接口，所以所有Collection接口的实现类都可以作为Iterable对象直接传入fromIterable()方法
4、
defer()方式

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

订阅时创建Observable，针对每个观察者创建一个新的Observable。
5、
interval()方式

Observable<Integer> observable = Observable.interval(1, TimeUnit.SECONDS);

创建一个按固定时间间隔发射整数序列的Observable，按间隔时间调用onNext()方法（持续进行）。
6、
range()方式

Observable<Integer> observable = Observable.range(1,20); // 表示发射从1开始到20的整数序列

创建一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数（即调用onNext()方法次数），如果为0则不发送，负数则抛异常。
7、
timer()方式

Observable<Integer> observable = Observable.timer(1, TimeUnit.SECONDS); // 定时1秒后，发送整数1事件(调用onNext()方法)

创建一个Observable，在给定的延迟后发射一个特定的值
8、repeat()方式

Observable<Integer> observable = Observable.just(1).repeat();

创建一个Observable，该Observable的事件可以重复调用

Disposable：
用于连接管理，其dispose()方法可断开将Observer(观察者)与Observable(被观察者)之间的连接（取消订阅）

public interface Subscription {  // 1.x使用, 可向生产者请求数据，又可以取消订阅、释放资源
    public void request(long n);  
    public void cancel();  
} 

//Represents a disposable resource.
public interface Disposable { // 2.x中替代Subscription
    // Dispose the resource, the operation should be idempotent.
    void dispose();
    boolean isDisposed();
}

Disposable获取方式

1、
CompositeDisposable composite = new CompositeDisposable();
composite.add(Flowable.range(1, 2).subscribeWith(subscriber)); // subscribeWith方法返回当前的Subscriber对象
composite.dispose()  //取消订阅

2、
Disposable disposable = Observable.just("one").subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
    }
});
disposable.dispose() //取消订阅

3、
DefaultSubscriber, ResourceSubscriber，DisposableSubscriber都实现了Disposable接口（资源跟踪支持）可通过它们的实例对象,调用dispose()来取消订阅
//public abstract class ResourceSubscriber<T> implements FlowableSubscriber<T>, Disposable {}   
ResourceSubscriber<Integer> subscriber = new ResourceSubscriber<Integer>() {
    @Override
    public void onStart() {
        request(Long.MAX_VALUE); // 请求资源
    }
    @Override
    public void onNext(Integer t) {
        System.out.println(t);
    }
    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }
    @Override
    public void onComplete() {
        System.out.println("Done");
    }
};
subscriber.dispose(); //取消订阅

4、
Disposable disposable;
Observer<String> observer = new Observer<String>() {
   @Override
   public void onSubscribe(Disposable d) {
      disposable = d;
   }
};

观察者模式创建步骤：
1、订阅者(观察者)创建
2、被观察者创建，变换、线程控制设置
3、订阅
4、被观察者的事件序列发送
5、订阅者事件响应

Disposable disposable;
Observable<Integer> observable = Observable.timer(1, TimeUnit.SECONDS); // 1、创建被观察者，timer()发送整数1事件(调用onNext()方法)
Observer<Integer> observer = new Observer<Integer>() { // 2、观察者
    @Override
    public void onSubscribe(Disposable d) {
        //Disposable是1.x的Subscription改名的，2.0之后新添加的
        //可使用d.dispose()方法取消订阅
        disposable = d;
    }
    @Override
    public void onNext(Integer t) { // 4、接收整数事件
        System.out.println(t);
    }
    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }
    @Override
    public void onComplete() {
        System.out.println("Done");
    }
};
observable.subscribe(observer); // 3、订阅

2、线程控制器Scheduler

RxJava遵循的是线程不变的原则：
在哪个线程调用subscribe()，就在哪个线程生产、消费事件
Scheduler切换线程：
RxJava通过Scheduler指定代码运行在哪种线程中，RxJava内置Scheduler：
Schedulers.immediate()：
默认的Scheduler，直接在当前线程运行。
包含用于延迟动作的阻塞睡眠，并且不支持递归调度。你可以使用Schedulers.trampoline代替Schedulers.immediate()
Schedulers.newThread()：
总是启用新线程，并在新线程执行操作。
Schedulers.io()：
I/O操作(读写文件、读写数据库、网络信息交互等）所使用的Scheduler。
行为模式和newThread()差不多，区别在于io()的内部实现是用一个无数量上限的线程池，可以重用空闲的线程，
因此多数情况下io()比newThread()更有效率。
不要把计算工作放在io()中，可以避免创建不必要的线程。
Schedulers.computation()：
计算所使用的Scheduler。计算指的是CPU密集型计算，即不会被I/O等操作限制性能的操作，如图形计算。
该Scheduler使用的固定的线程池，大小为CPU核数。
不要把I/O操作放在computation()中，否则I/O操作的等待时间会浪费CPU。
Android 专用的 AndroidSchedulers.mainThread()，它指定操作将在Android主线程运行。

可以使用subscribeOn()和observeOn()方法来对线程进行控制了。
subscribeOn(): 指定Observable(被观察者、事件生产者)所在的线程。 
observeOn():   指定Observer(观察者、事件消费者)所运行在的线程。

3、操作符

为解决对象变换问题而设计，操作符可以在传递的途中将事件序列中的对象或整个序列进行修改，转换成不同的事件或事件序列
（用于转换Observable为其它观察者对象所期望的新的Observer的过程）
map()
将其转换为与之不同的对象，对应返回的Observable/Flowable对象参数也会变为转换后的对象，一对一的变换。
（原来的Observable对象转换成另一个Observable对象，将传输的数据进行一些操作，以便Observer获得想要的数据形式）
flatMap()
flatMap可以是一对多的转换，flatmap()重新生成一个Observable对象，并把数据转换成Observer想要的数据形式
filter()
根据自己想过滤的数据加入相应的逻辑判断，返回true则表示数据满足条件，返回false则表示数据需要被过滤。最后过滤出的数据将加入到新的Observable对象中，方便传递给Observer想要的数据形式
doOnNext()
允许在每次输出一个元素之前做一些额外的事情，比如提示、保存类的操作
doOnSubscribe()
这个操作符跟onStart方法一样，都是在subscribe()方法调用后且事件发送之前执行,可做数据初始化操作。
默认情况下,doOnSubscribe()执行在subscribe()发生的线程，如果在doOnSubscribe()之后有subscribeOn()的话，
它将执行在离它最近的subscribeOn()所指定的线程中，doOnSubscribe()之后的subscribeOn()且是最近的才会影响它
timer()
做定时操作
interval()
做周期性操作
lift()和compose()
lift() 对事件项和事件序列,lift(Operator)
//1.x 
public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> { }
lift(Operator<? extends R, ? super T> operator)  //用来转换Subscriber  
//2.x  
public final <R> Single<R> lift(final SingleOperator<? extends R, ? super T> lift)

compose() 对Observable自身进行变换,compose(Transformer)
//1.x  
public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> { }  
compose(Transformer<? super T, ? extends R> transformer)//用来转换Observable，如bindUtilEvent  
//2.x
public final <R> Flowable<R> compose(FlowableTransformer<? super T, ? extends R> composer)
concat()和merge()
range()
第一个参数为开始值，第二个参数为数量
filter()
方法用于对数据进行过滤
take(n)
方法用于取前n个值

4、功能接口

Action：
Consumer、BiConsumer、Consumer<Object[]>
Function
Function、BiFunction、Function3-9、Function<Object[],R>
//泛型第一个为接收参数的数据类型，第二个为转换后要发射的数据类型

5、Flowable Backpressure
被观察者是事件的生产者，观察者是事件的消费者。当生产者不断生成事件，消费者不能实时的消费事件，造成消费者端事件堆积，Flowable（Backpressure背压–观察者端对事件缓存、处理的方式，主要操作RxJava缓存池，默认大小为128）用于解决此类问题的！

Backpressure处理策略：
ERROR
缓存池溢出，立刻抛出MissingBackpressureException异常
BUFFER
把RxJava中默认的只能存128个事件的缓存池换成一个大的缓存池，支持存很多的数据缓存
DROP
把消费者处理不了的事件丢弃
LATEST
与DROP功能基本一致。
唯一的区别就是LATEST总能使消费者能够接收到生产者产生的最后一个事件

//Represents the options for applying backpressure to a source sequence.
public enum BackpressureStrategy {
    // OnNext events are written without any buffering or dropping.Downstream has to deal with any overflow.
    // <p>Useful when one applies one of the custom-parameter onBackpressureXXX operators.
    MISSING,
    ERROR, //Signals a MissingBackpressureException in case the downstream can't keep up.
    BUFFER, //Buffers <em>all</em> onNext values until the downstream consumes it.
    DROP, //Drops the most recent onNext value if the downstream can't keep up.
    LATEST //Keeps only the latest onNext value, overwriting any previous value if the downstream can't keep up.
}

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {
    @Override
    public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onComplete();
    }
}, BackpressureStrategy.ERROR); 
//1、Backpressure使用方式1，ERROR策略：异步调用时，缓存池溢出，则抛出MissingBackpressureException异常，此时消费者不能再接收事件，但生产者并不会停止事件发送

Subscriber<Integer> subscriber = new Subscriber<Integer>() {
    @Override
    public void onSubscribe(Subscription s) { 
    // Subscription可用于切断观察者与被观察者间的联系(调用Subscription.cancel())
        mSubscription = s; // 外部mSubscription变量赋值（外部操作该Subscription，Subscription负责流和资源的生命周期管理，即申请以及退订、释放资源），通过这种方式组织新的背压关系
        s.request(Long.MAX_VALUE);  // 2.x中，onSubscribe()回调中须调用s.request()方法去请求资源（向生产者申请可接收、消费的事件数量，不显示调用request就表示消费能力为0）
    }
    @Override
    public void onNext(Integer t) {
        System.out.println(t);
    }
    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }
    @Override
    public void onComplete() {
        System.out.println("Done");
    }
};

flowable.subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(subscriber); 

Flowable.just(1)
        .onBackpressureBuffer(256) // 1、Backpressure使用方式2，onBackpressureBuffer()、onBackpressureDrop() onBackpressureLatest()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Consumer<Integer>() {
             @Override
             public void accept(Integer integer) throws Exception {
                Log.d("Subscriber", "accept: " + integer);
             }
        });