Rxjava源码分析

最新推荐文章于 2024-01-09 10:05:02 发布

qq_26414049

最新推荐文章于 2024-01-09 10:05:02 发布

阅读量142

点赞数

文章标签： android

本文链接：https://blog.csdn.net/qq_26414049/article/details/118103252

版权

本文深入剖析 RxJava 的 Observable 创建与订阅过程，通过源码分析 `create` 和 `subscribe` 方法的工作原理。同时，探讨 `map` 和 `flatMap` 的区别，解释它们在数据转换和处理中的不同角色。文中还展示了如何在实际应用中使用 `doOnNext` 替代 `subscribe` 进行中间操作，并提供了相关代码示例。

摘要由CSDN通过智能技术生成

一、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
}
});

qq_26414049

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Rxjava源码分析

一、RxJava案例和流程 // 结论： new ObservableCreate() {source == 自定义source} // 2：Observable创建过程源码分析 Observable.create( // 自定义source new ObservableOnSubscribe<String>() { @Override publi.
复制链接

扫一扫