一、RxJava案例和流程
// 结论: new ObservableCreate() {source == 自定义source}
// 2:Observable创建过程 源码分析
Observable.create(
// 自定义source
new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
// 发射器.onNext
emitter.onNext("A");
}
})
// 3:subscribe订阅过程 源码分析
// ObservableCreate. subscribe
.subscribe(
// 自定义观察者
// 1:Observer 源码看看
new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
这是一个标注的RxJava使用例子,其实这个流程就是先从上往下一级一级的封装对应的Observable,然后再从下往上通过Observable.subscribe订阅向上传递Observer观察者,最后ObservableCreate中将Observer进行封装CreateEmitter,调用ObservableOnSubscribe.subscribe(emitter)用于业务中通知,CreateEmitter是ObservableEmitter子类实现,是ObservableCreate的静态内部类
RxJavaPlugins.onAssembly
在具体分析之前,首先先看RxJavaPlugins.onAssembly的具体实现,RxJavaPlugins.onAssembly方法可以说贯穿整个RxJava流程,RxJavaPlugins.onAssembly方法目的就是作为一个钩子函数,将之前的Observable进行封装,变成一个新的Observable。
在上面的例子中,这里的f对象一直都是null。
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
Observable的创建过程源码分析:
被观察者 Observable调用create方法,就是我们把自定义ObservableOnSubscribe对象,包装成ObservableCreate对象,然后再返回ObservableCreate
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
subscribe订阅过程 源码分析
如箭头所示链式调用,此时Observable.create方法之后,此时会返回ObservableCreate对象,现在点击subscribe跳转过去
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
所有的Observable以及子类调用subscribe方法时,都是调用Observable.subscribe(),所以在上述流程中,第一个调用subscribe()方法的就是ObservableObServeOn这个Observable子类,ObservableObServeOn是在observeOn()方法中对上一个Observable进行封装创建的。
这其中 subscribeActual(observer),
就到ObservableCreate.subscribeActual(Observer <? super observer>)
其中CreateEmitter<T> parent=new CreateEmitter<T>(observer),新创建了一个CreateEmitter,
CreateEmitter是ObservableEmitter子类实现,是ObservableCreate的静态内部类,这其中的source就是我们Obserable.create传递过来的,自定义source
然后创建好了的CreateEmitter引用的parent就这样传递回来了,如上图的emitter就是我们ObservableCreate.subscribeActual()方法中的source.subscribe(parent)等价于emitter.onNext("A")
1.分析map和flatMap的区别
// ObseravbleCreate 自定义source传递进去了 == source
Observable.create(
// 自定义source
new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
}
})
// ObseravbleCreate.map
.map(new Function<String, Bitmap>() {
@Override
public Bitmap apply(String s) throws Exception {
return null;
}
})
// ObservableMap.subscribe
.subscribe(
// 自定义观察者(终点)
new Observer<Bitmap>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Bitmap bitmap) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
对上面的流程进行分析的
observable.create()调用了,上面有介绍这就不介绍了
此时得到了ObseravbleCreate 对象,
// ObseravbleCreate.map
ObseravbleCreate.map(new Function<String, Bitmap>() { @Override public Bitmap apply(String s) throws Exception { return null; } })
从ObseravbleCreate点击进去,
ObjectHelper.requireNonNull(mapper,"mapper is null") 检查mappper是否为null
就创建成 ObservableMap(ObservableCreate(source,mapper)) 此时是source为自定义的source,
ObservableMap 继承了AbstractObservableWithUpStream,我们接着往下看,AbstractObservableWithUpStream extends Observable被观察者,上界通配符,AbstractObservableWithUpStream 实现了 HasUpstreamObservableSource
然而HasUpstreamObservableSource这个接口类中,有ObservableSource
public interface HasUpstreamObservableSource<T> {
/**
* Returns the upstream source of this Observable.
* <p>Allows discovering the chain of observables.
* @return the source ObservableSource
*/
ObservableSource<T> source();
}
ObservableSource类中,有关联Observer
public interface ObservableSource<T> {
/**
* Subscribes the given Observer to this ObservableSource instance.
* @param observer the Observer, not null
* @throws NullPointerException if {@code observer} is null
*/
void subscribe(@NonNull Observer<? super T> observer);
}
1.分析map和flatMap的区别
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
return flatMap(mapper, false);
}
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
要分析两个操作符的区别,首先看源码。
比如在map和flatMap两个操作符中,分别做网络请求,那么在map中,就会有问题。
因为如果在flatMap中执行Retrofit请求接口,返回的是一个Observable<T>,那么可以看出,如果是使用flatMap的话,则flatMap中的泛型<R>其实是接口请求的返回值的Observable<T>的泛型T,而如果是使用map的话,那么map中的泛型<R>其实就是接口请求返回值Observable<T>,那么map的返回值就会变成Observable<Observable<T>>,这结构出现了变化
所以map主要是用来做数据类型的转换的,从一个数据类型转为另外一个数据类型,而不会影响这个数据类型在Observable的,比如转换之前是Observable<T>,转换之后变成Observable<R>,依然是Observable结构的,转换的只是Observable中的泛型的类型。
而flatMap的话,可以使用Observable的泛型类型数据,得到一个新的Observable,然后使用这个新的Observable替代了旧的Observable
flatMap在实际应用场景中,可能会出现一个接口的请求你数据需要借助于前一个接口,这样的接口多层嵌套的情况,在这样的情况下,可以借助于flatMap来简化嵌套层次,在flatMap中还可以借助于Observable.fromIterable实现一个发射器功能,即遍历一个数组或者集合,然后按集合的长度进行遍历发射,这样在这个flatMap的后面的观察者就会执行多次。
doOnNext
使用doOnNext代替subscribe,使用doOnNext在两个请求的中间进行一次UI更新操作
MyRetrofit.createRetrofit().create(TestApi.class)
.register("55082207@qq.com", "123456", "123456")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.doOnNext(new Consumer<LoginResponse>() {
@Override
public void accept(LoginResponse loginResponse) throws Exception {
// todo 注册完成之后更新ui
}
})
.observeOn(Schedulers.io())
.flatMap(new Function<LoginResponse, ObservableSource<LoginResponse>>() {
@Override
public ObservableSource<LoginResponse> apply(LoginResponse loginResponse) throws Exception {
Observable<LoginResponse> observable = MyRetrofit.createRetrofit().create(TestApi.class)
.loginWanAndroid(loginResponse.getData().getUsername(), loginResponse.getData().getPassword());
return observable;
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<LoginResponse>() {
@Override
public void onSubscribe(Disposable d) {
// todo 然后在BaseModel对生命周期的回调中mCompositeDisposable?.dispose()
// todo 显示加载中的dialog
}
@Override
public void onNext(LoginResponse loginResponse) {
// todo 登录完成之后更新UI
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
// todo 登录完成之后才会回调complete,关闭dialog
}
});