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();