RxJava操作符——Observable.from

使用

from操作符支持传入Iterable或者数组然后创建一个Observable，在开启订阅的时候会将Iterable或者数组中的元素当成事件内容依次发出

List<String> yys = new ArrayList<>();
yys.add("野猿新一");
yys.add("野猿新二");
yys.add("野猿新三");
Observable.from(yys)
        .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d("Himmy", s);
            }
        });

输出结果

02-17 15:46:26.577 12442-12442/com.him.hisapp D/Himmy: 野猿新一
02-17 15:46:26.577 12442-12442/com.him.hisapp D/Himmy: 野猿新二
02-17 15:46:26.577 12442-12442/com.him.hisapp D/Himmy: 野猿新三

源码解析

为了降低理解难度，本文解析基于1.0.0版本源码

from(T[] array)内部其实是调用from(Iterable<? extends T> iterable)，通过asList先将数组转成Iterable

public final static <T> Observable<T> from(T[] array) {
    return from(Arrays.asList(array));
}

 from(Iterable<? extends T> iterable)中调用create方法创建一个Observable，参数是OnSubscribeFromIterable类型

public final static <T> Observable<T> from(Iterable<? extends T> iterable) {
    return create(new OnSubscribeFromIterable<T>(iterable));
}

接下来OnSubscribeFromIterable的内部实现，OnSubscribeFromIterable继承OnSubscribe，主要看其内部实现的call()方法，该方法用于发出事件，通过o.setProducer设置一个IterableProducer

@Override
public void call(final Subscriber<? super T> o) {
    final Iterator<? extends T> it = is.iterator();
    o.setProducer(new IterableProducer<T>(o, it));
}

我们先看下Subscriber.setProducer()方法的内部实现的伪代码，其内部最终是调用Producer的request()方法

public void setProducer(Producer producer) {
    // 省略其他代码
    p.request(Long.MAX_VALUE);
    // 省略其他代码
}

接下来看IterableProducer.request()方法的内部实现伪代码，其内部将Iterator中的元素一个个取出来，然后通过onNext发送出去，在Subscriber中就可以依次接收到这些消息

private static final class IterableProducer<T> implements Producer {
    private final Subscriber<? super T> o;
    private final Iterator<? extends T> it;

    private IterableProducer(Subscriber<? super T> o, Iterator<? extends T> it) {
        this.o = o;
        this.it = it;
    }

    @Override
    public void request(long n) {
        // 省略其他代码
        while (it.hasNext()) {
            if (o.isUnsubscribed()) {
                return;
            }
            o.onNext(it.next());
        }
        if (!o.isUnsubscribed()) {
            o.onCompleted();
        }
        // 省略其他代码
    }
}

了解了from方法的内部实现，我们也可以自己写一个from

public final static <T> Observable<T> from(final Iterable<? extends T> iterable) {
    return Observable.create(new Observable.OnSubscribe<T>() {
        @Override
        public void call(Subscriber<? super T> subscriber) {
            Iterator<? extends T> it = iterable.iterator();
            while (it.hasNext()) {
                subscriber.onNext(it.next());
            }
            subscriber.onCompleted();
        }
    });
}

结果是一样的，至于RxJava中为何要实现得那么复杂(比上面展示的伪代码还复杂)肯定有其原因，只是我目前功力不够也没去深究

private void test() {
    final List<String> yys = new ArrayList<>();
    yys.add("野猿新一");
    yys.add("野猿新二");
    yys.add("野猿新三");
    from(yys).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.d("Himmy", s);
        }
    });
}