Rxjava2源码学习(一)

这一篇主要看一下Rxjava的链式调用(Builder设计模式) 和 数据如何实现传输。

首先看一下下面这个简单的代码片段:

Observable.create(new ObservableOnSubscribe<String>() {
       @Override
       public void subscribe(ObservableEmitter<String> emitter) throws Exception {
           emitter.onNext("test");
       }
   })
   .subscribeOn(Schedulers.io())
   .observeOn(AndroidSchedulers.mainThread())
   .subscribe(new Observer<String>() {
       @Override
       public void onSubscribe(Disposable d) {

       }

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

       @Override
       public void onError(Throwable e) {

       }

       @Override
       public void onComplete() {

       }
   });

链式调用

我们先看一下链式调用的实现:
Rxjava采用的是链式调用,比如我们看一下Observable.create()方法

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

那返回的RxJavaPlugins.onAssembly又是什么呢?

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()之后得到的是一个Observable对象,接着看

.subscribeOn(Schedulers.io())

通过上面我们可以知道,RxJavaPlugins.onAssembly返回的是Observable对象,所以subscribeOn方法中返回的也是一个Observable对象。

public final Observable<T> subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}

两者不同的是new的对象不一样。

class ObservableCreate<T> extends Observable<T>

class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T>
class AbstractObservableWithUpstream<T, U> extends Observable<U>

但是他们都是继承自Observable。

接着我们看

.observeOn(AndroidSchedulers.mainThread())
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

不是猜,返回的也是Observable对象

class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T>
class AbstractObservableWithUpstream<T, U> extends Observable<U>

通过不断的返回Observable对象,实现了链式调用。

数据传输

数据传输的核心思想是接口的回调机制来实现的,通过接口的定义声明和具体实现来完成数据的传输。
不妨先回忆一下RecyclerView的item点击事件。
RecyclerView本身是没有item的点击事件的,那我们自己写的时候是如何实现呢?
我们一般先定义一个点击事件的Listener。

interface ItemClickListener{
    fun setOnItemClick(position: Int)
}

我们在Adapter中声明这个点击事件,在item的需要点击的地方,例如整个item,对viewHolder.setOnClickListener的具体实现中,声明我们定义的Listener,例如listener.setOnItemClick。

holder.itemView.setOnClickListener {
   listener!!.setOnItemClick(position)
}

然后我们在Activity或者Fragment中,我们需要实现这个Listener,这样我们在点击item的时候,通过viewHolder实现的点击事件,再通过自定义的Listener的声明,我们在Activity或者Fragment中的Listener的具体实现中就能拿到我们需要的数据,例如position了。

adapter.setItemClickListener(object : ItemClickListener{
    override fun setOnItemClick(position: Int) {
        //接口具体的实现
    }

})

Rxjava中数据传输的本质也是通过上述的方式实现的。
这里的数据传输暂时不包括线程切换这一块。

还是拿上面的例子去掉线程切换这块来说:

 Observable.create(new ObservableOnSubscribe<String>() {
   @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("test");
    }
})
.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {

    }

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

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});
Observable.create(new ObservableOnSubscribe<String>() {
   @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("test");
    }
})

我们以create方法为例,create方法将ObservableOnSubscribe接口的具体实现的地址作为source,

return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));

在create方法中,通过new ObservableCreate(source)创造一个observable对象(ObservableCreate对象继承自Observable)。最后调用RxJavaPlugins.onAssembly(new ObservableCreate(source));返回该Observable对象

我们来看一下ObservableCreate类是怎么做的:
ObservableCreate继承自Observable,实现了它的subscribeActual(Observer

protected abstract void subscribeActual(Observer<? super T> observer);

我这里只保留了关键代码

public final void subscribe(Observer<? super T> observer) {

        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {

        }
    }

当Observable调用subscribe方法时,真正调用的是subscribeActual方法。
那我们回到ObservableCreate类中看看subscribeActual方法做了什么:

protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

这里首先new了一个CreateEmitter(数据发射器),构造函数中加入了Observable的Subscribe方法中传入的Observer对象。然后

source.subscribe(parent);

这里的source就是上面create的时候传入的ObservableOnSubscribe对象。到这里为止,有没有联想到之前提的recycleview点击事件的例子?

public interface ObservableOnSubscribe<T> {

    /**
     * Called for each Observer that subscribes.
     * @param emitter the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

ObservableOnSubscribe是一个接口,它的subscribe方法中需要的是一个数据发射器,在Observable的create方法中new一个ObservableOnSubscribe对象作为source之后,这个source在ObservableCreate类中订阅了发射器,拿到了我们刚new出来的CreateEmitter对象(类似于recycleview例子中adapter中拿到的position),在外部的ObservableOnSubscribe的具体实现中我们拿到了这个CreateEmitter对象,用于发射数据。

同理我们在反过来,在Observable中的create方法中,ObservableOnSubscribe的subscribe方法中我们拿到了CreateEmitter对象,

public interface ObservableEmitter<T> extends Emitter<T> 

继承自Emitter接口

public interface Emitter<T> {

    /**
     * Signal a normal value.
     * @param value the value to signal, not null
     */
    void onNext(@NonNull T value);

    /**
     * Signal a Throwable exception.
     * @param error the Throwable to signal, not null
     */
    void onError(@NonNull Throwable error);

    /**
     * Signal a completion.
     */
    void onComplete();
}

在外部调声明接口,并调用它的方法

emitter.onNext("test");

在内部的CreateEmitter类中有它的具体实现

static final class CreateEmitter<T> implements ObservableEmitter<T>{
    @Override
    public void onNext(T t) {

        //关键代码
        observer.onNext(t);

    }
}

这里的思想像是之前RecyclerView例子的翻转,在外部对于接口的声明,在内部实现它,并做下一步的处理。

到此数据就通过ObservableOnSubscribe对象拿到的ObservableEmitter发射器,调用发射数据的代码,到达了其具体实现的地方,我们可以看到,在其具体实现的地方,调用了

observer.onNext(t);

这里的本质是和第一步获取发射器是一样的。

.subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

在外部是Observer对象的具体实现,作为参数传入subscribe方法中。通过

subscribeActual(observer);

进入到ObservableCreate类中,再通过

CreateEmitter<T> parent = new CreateEmitter<T>(observer);

进入到CreateEmitter类中,在CreateEmitter的具体实现,例如onNext方法中,声明这个接口的方法,上面已经提到过了:

static final class CreateEmitter<T> implements ObservableEmitter<T>{
    @Override
    public void onNext(T t) {

        //关键代码
        observer.onNext(t);

    }
}

很熟悉是不是,这里是内部的Observer接口方法的调用,外部是接口方法的具体实现。

最后附上一张画的不是很好的原理图:
这里写图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值