Rxjava2~from****那么多方法~学渣带你扣rxjava2

我都不知道自己哪里来的毅力。死扣这几个方法 但是 我想在就是想。 这几个方法 扣到哪里算哪里。今天没完成,会在转天继续完成。我会一直补充

Paste_Image.png

fromCallable

Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.

This allows you to defer the execution of the function you specify until an observer subscribes to the ObservableSource. That is to say, it makes the function "lazy."

这是官网的解释。

Calls a Callable and emits its resulting single value or signals its exception.
这句话是对
ObservableFromCallable的描述

我们现不解释 先来看来那个例子
<pre>

    Observable.fromCallable(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            return Observable.just("one", "two", "three", "four", "five");
        }
    }).subscribe( getSubscriber() );

    Observable.defer(new Callable<ObservableSource<? extends String>>() {
        @Override
        public ObservableSource<? extends String> call() throws Exception {
            // Do some long running operation
            SystemClock.sleep(2000);
            return Observable.just("one", "two", "three", "four", "five");
        }
    }).subscribe( getSubscriber() );



 Observer<Object> getSubscriber() {
    return new Observer<Object>() {

        @Override
        public void onError(Throwable e) {
            Log.i("RxJava", "onError : " + e.toString());
        }

        @Override
        public void onComplete() {
            Log.i("RxJava", "onCompleted");

        }

        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Object o) {
            Log.i("RxJava", "onNext : " + o);
            Log.i("RxJava", Thread.currentThread().getName());
        }
    };
}

</pre>

<pre>
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : io.reactivex.internal.operators.observable.ObservableFromArray@39ee6818
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:53.313 26651-26651/com.rxjava2.android.samples I/RxJava: onCompleted
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : one
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : two
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : three
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : four
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onNext : five
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: main
06-23 08:55:55.315 26651-26651/com.rxjava2.android.samples I/RxJava: onCompleted
</pre>

可以看出来来什么?fromCallable的接口直接传过来的是一个对象,defer根据对象个的个人分别传送。这是因为什么呢? 我们往下看

这是ObservableDefer的subscribeActual
<pre>
public void subscribeActual(Observer<? super T> s) {
ObservableSource<? extends T> pub;
try {
pub = ObjectHelper.requireNonNull(supplier.call(), "null publisher supplied");
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
EmptyDisposable.error(t, s);
return;
}

    pub.subscribe(s);
}

</pre>
我们之前分析过pub.subscribe(s);这方法决定了 。 你call的值还是要按照Observable对象的创建方式去别人调用onnext这些方法。

这是ObservableFromCallable的subscribeActual
<pre>
public void subscribeActual(Observer<? super T> s) {
DeferredScalarDisposable<T> d = new DeferredScalarDisposable<T>(s);
s.onSubscribe(d);
if (d.isDisposed()) {
return;
}
T value;
try {
value = ObjectHelper.requireNonNull(callable.call(), "Callable returned null");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
if (!d.isDisposed()) {
s.onError(e);
} else {
RxJavaPlugins.onError(e);
}
return;
}
d.complete(value);
}
</pre>

发现了没有这个并没有。而是直接一个value,全部发送回去。
因此 我们可以说这个方法。回调回去的值不论几个都会全部发送

下面看第二个方法

Observable.fromArray()这个方法
<pre>
public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
if (items.length == 0) {
return empty();
} else
if (items.length == 1) {
return just(items[0]);
}
return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}
</pre>

看着眼熟吗? 没错和just 一模一样。区别 just有数量限制

第三个方法
fromFuture

推荐阅读更多精彩内容

  • 新年的钟声即将敲响之际,一位朋友恋恋不舍地挥泪告别了挚爱着他的亲朋好友,孤身一人去往了遥远的天国。 朋友年迈的老母...
    袖西风阅读 155评论 1 0
  • 回忆季 过去已过去,既然已成既然…… 多年以后 ,我一如既往的来到家附近的的咖啡店,见到了翰墨...
    413_e98f阅读 62评论 0 0
  • 我在自己的签名栏里一直都写的是:希望用英语去工作,用日语去旅行,用中文去写字。 很多朋友问我:“你同时做那么多事情...
    May_ame阅读 10,564评论 235 496
  • 【居家草本‧DIY通用家用清潔劑】 安全、天然、有效、潔淨 一 可準備一個玻璃噴霧瓶,四分之一用白醋填滿,其餘用水...
    生命的别样年华阅读 79评论 0 0
  • 刚写的一首七绝,送给曾经在东方广场与我共事的那些“娘家人”,只想对你们说:虽然一别数年,我依然想念你们,怀念在那里...
    Odette伊菲阅读 105评论 0 2