RxJava响应式编程详解

RxJava的概念

1. RxJava的介绍:
一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库

Rxlava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based program:  'by using observable sequences.

2. RxJava的优势:
简洁-随着程序逻辑变得越来越复杂,它依然能够保持简洁                                                                                                                      高效-快速开发,代码一条从上到下的链式调用

1. RxJava基础:
观察者模式
响应式编程基础
RxJava的API及源码分析

2. RxJava系列框架:
RxAndroid, RxBinding, Retrofit框架-RxJava, RxLifecycle, RxPermissions

 

异步操作: Rxjava系列
网络请求: Retrofit
数据绑定: DataBinding
图片浏览: PhotoView
图片加载: Glide, Picasso

观察者模式

响应式-观察者模式的进阶

 RxJava详解

 

更加简洁的展示方式-Lambda

1、RxJava中使用lambdaJava8 引入了Lambda表达式,使代码更简洁。

Java 6+ & Android 2.3+Java 8 lambda support

Android中,通过导入retrolambda(gradle插件),来使用lambda.

dependencies {
     classpath 'me.tatarka:gradle-retrolambda:3.3.1'
}

RxJava的操作符 :https://blog.csdn.net/qq_42179105/article/details/84800814

线程控制- Scheduler

1. Scheduler的API :
用于控制操作符和被观察者事件,所执行的线程
不同的调度器,对应不同的线程
调度器的分类:
Schedulers.immediate():默认线程
Schedulers.newThread():新建线程
Schedulers.io():适用于I/0操作(线程池)
Schedulers.computation():适用于计算工作(线程池)                                                                                                Schedulers.trampoline()：当前线程,队列执行

 

如何进行线程调度?
使用ObserveOn()和subscribeOn()操作符

subscribeOn():指定subscribe()所发生的线程,即Observable.OnSubscribe被激活时所处的线程。或者叫做事件产生的线程。

observeOn():指定Subscriber所运行在的线程。或者叫做事件消费的线程。

 

1.Scheduler 的原理

RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。

• subscribeOn() 原理图：

subscribeOn()通过操作特定的Scheduler，通知Observable在指定线程执行。

• observeOn() 原理图：

ObserveOn()通过操作特定的Scheduler，让Observable指定Observers的执行线程；

RxJava原理分析

1、基本结构
创建Observable
创建Subscriber
订阅subscribe()

基本流程分析

1.基本结构

我们先来看看，RxJava基本代码：

//被观察者
Observable observable = Observable.create(
                             new Observable.OnSubscribe() {
    @Override
    public void call(Subscribersuper String> subscriber) {
        subscriber.onNext("Hello World");
        subscriber.onNext("Hello Keye");
        subscriber.onNext("Hello jikexueyuan");
        subscriber.onCompleted();
        subscriber.onError();
    }
});

//观察者
Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
                Logger.d("onCompleted()");
            }

            @Override
            public void onError(Throwable e) {
                Logger.d("onError:" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Logger.d("onNext():" + s);
            }
        };

//观察者订阅被观察者
observable.subscribe(observer);

在调用subscribe()方法后，observer作为参数传入OnSubscribe的call()方法中，observable通过call()方法，来调用observer的onNext()，onCompleted()，onError()方法。从而实现了事件的传递。

2.流程分析

来看看源码是如何实现的：

创建Observable时：

Observable.create(onSubscribe);

//Observable的create()方法
public static  Observable create(OnSubscribe f) {
    return new Observable(hook.onCreate(f));
}

//Observable的构造方法
protected Observable(OnSubscribe f) {
    this.onSubscribe = f;
}

//RxJavaObservableExecutionHook的onCreate()方法
public  OnSubscribe onCreate(OnSubscribe f) {
    return f;
}

这里直接调用构造方法，来创建一个Observable对象。构造方法中传入一个OnSubscribe对象，赋值给新建的Observable对象中的OnSubscribe。

扩展：追溯源码发现，Observable的生命周期方法中都有RxJavaObservableExecutionHook的身影，它的onCreate()方法只是传入参数再返回，没有其他操作。这里可以理解为把ExecutionHook注入到Observable的生命周期中，它默认无任何操作，可以通过RxJavaPlugin.getInstance()方法，自定义hook进行相关扩展。我们暂时用不到，先不管它。

创建Subscriber时：

public abstract class Subscriber<T> implements Observer<T>, Subscription {...}

public interface Observer<T> {
    void onCompleted();
    void onError(Throwable e);
    void onNext(T t);
}

Subscriber是一个继承了Observer(观察者)接口的抽象方法，它重写它了的onNext()，onCompleted()，onError()方法，并进行了一些扩展；

public interface Subscription {
    //取消订阅
    void unsubscribe();
    //是否取消了订阅
    boolean isUnsubscribed();
}

另外Subscriber还继承了Subscription接口，方便取消订阅和查询订阅状态。

订阅subscribe()时：

private static  Subscription subscribe(Subscribersuper T> subscriber, Observable observable) {
    
        // new Subscriber so onStart it
        subscriber.onStart();
 
        observable.onSubscribe.call(subscriber);
        
        return hook.onSubscribeReturn(subscriber);
    }
}

这里只写出了源码的核心部分，可以看到subscribe()传入了Subscriber和observable；

首先，调用subscriber的onStart()方法，在订阅之前执行一些准备代码。

之后，Observable中的onSubscribe对象调用call()，传入subscriber作为参数。

最后，返回一个Subscription对象；之前提到过hook对象是没有任何操作的，也就是说返回的是一个实现Subscription接口的subscriber，便于取消和查询订阅。

操作符源码分析

1.Observable对象的变换

之前的课时，讲解了RxJava的变换操作符，可以把事件或者队列转进行转变，变成新的事件或队列再发送出去。作为RxJava的一个核心功能，来看看源码是怎么实现的：

map()方法:

对Observable发射的每一项数据应用一个函数，执行变换操作：

public final  Observable map(Func1super T, ? extends R> func) {
    return lift(new OperatorMap(func));
}

下图展示了如何将一个乘法函数应用到每个发出的值上，以此创建一个新的Observable来发射转换的数据。

flatMap()方法:

有一个这样的Observable：它发射一个数据序列，这些数据本身也可以发射Observable。RxJava的flatMap()函数提供一种铺平序列的方式，然后合并这些Observables发射的数据，最后将合并后的结果作为最终的Observable。

public final  Observable flatMap(Func1super T, ? extends Observable> func) {
    if (getClass() == ScalarSynchronousObservable.class) {
        return ((ScalarSynchronousObservable)this).scalarFlatMap(func);
    }
    return merge(map(func));
}

当我们在处理可能有大量的Observables时，重要是记住任何一个Observables发生错误的情况，flatMap()将会触发它自己的onError()函数并放弃整个链。

提示：关于合并部分，它允许交叉。正如上图所示，这意味着flatMap()不能够保证在最终生成的Observable中源Observables确切的发射顺序。

2.变换的原理：lift()和compose()

lift():

在变换操作符的内部，都调用了lift()方法，它是一个基础的变换方法。

//lift方法源码
public final  Observable lift(final Operatorsuper T> operator) {
    return new Observable(new OnSubscribe() {
        @Override
        public void call(Subscribersuper R> o) {
        
          Subscribersuper T> st = hook.onLift(operator).call(o);
          st.onStart();
          onSubscribe.call(st);
        }
    });
}

//Operator是Observable内部定义的接口，继承了Func1接口
public interface Operator<R, T> extends Func1<Subscribersuper R>, Subscribersuper T>> {
    // cover for generics insanity
}

//Func1接口，传入一个泛型对象，返回一个R类型的对象
public interface Func1<T, R> extends Function {
    R call(T t);
}

官方解释：对一个Observale执行lift()方法，它会返回一个新的Observable；当订阅以后，新的Observable会通过相应的操作符把原Observable的数据传递出去。

流程：

（1）lift()先创建一个新的Observable，并传入一个新的OnSubscribe对象；

（2）当subscribe()订阅后，新Observable的新OnSubscribe会调用call()方法；

（3）OnSubscribe的call()中，hook的onLift()方法没有操作，相当于Operator调用了call()方法，传入原Subscriber，并创建一个新的Subscriber；

（4）新的Subscriber执行onStart()，进行订阅前的准备代码；原Observable的原onSubscribe调用call()方法，传入新的Subscriber；到这里就实现了Observable的类型转换，并且发送出去。

compose():

compose()方法应用一个特殊的变换方法对一个Observable对象进行转换。

//compose()方法
public  Observable compose(Transformersuper T, ? extends R> transformer) {
    return ((Transformer) transformer).call(this);
}

//Transformer接口，继承Func1接口，
public interface Transformer<T, R> extends Func1<Observable<T>, Observable<R>> {
    // cover for generics insanity
}

同样是变换，那它和lift()有什么不同呢？

compose()方法是操作Observable本身，而lift()是操作Observable 的Subscribers 或者Observers

使用场景：

（1）如果所创建的操作符是旨在操作由原Observable发射的独立事件，选择lift()方法；

（2）如果你的操作符是为了旨在变换原Observable本身（比如用一些特殊的RxJava已有的操作符），选择compose()方法。

 

Retrofit的概念

Retrofit是Square公司开发的,面向Android和Java的,一个类型安全的网络请求客户端。
通过注解的方式,设置请求类型;如: @POST(")

 Retrofit的基本使用

Retrofit retrofit = new Retrofit. Builder()    

....build();                    // Retrofit初始化

 

public interface GitHub {          //订阅请求接口

@ (GET"")                          //注释描述请求类型
Call> getDatas () 

Call> call=retrofit.create(GitHub.class).
getDatas ("paraml", "param2");    //调用接口，重新回调方法

1·如何使用Retrofit与RxJava结合
Retrofit的基本使用方式,同样是链式调用用Observable代替CallkT>接口添加addCallAdapterFactory()方法, RxJavaCallAdapterFactory类

new Retrofit. Builder() 
.baseUrl (API URL)
.addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();