rxJava的使用--Observable的创建及源码分析(三)

9,range,代码如下:

  Observable.range(1, 10).subscribe(new Subscriber<Integer>() {
            @Override
            public void onNext(Integer item) {
                System.out.println("Next: " + item);
            }

            @Override
            public void onError(Throwable error) {
                System.err.println("Error: " + error.getMessage());
            }

            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }
        });

运行结果如下:

---- onNext ----1
---- onNext ----2
---- onNext ----3
---- onNext ----4
---- onCompleted ----

从结果看,range自动为我们创建1~4之间的值,并自动调用onNext.
源码分析如下:

public static Observable<Integer> range(int start, int count) {
        ... 忽略部分
        // 这里看到如果count为1,调用的的是just来创建Observable对象的
        if(count == 1) {
            return Observable.just(start);
        }
        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
    }

接着看OnSubscribeRange里面的call方法:

  @Override
    public void call(final Subscriber<? super Integer> childSubscriber) {
        childSubscriber.setProducer(new RangeProducer(childSubscriber,startIndex,endIndex));
    }

经过前面的分析,看到setProducer我们应该知道直接去看,RangeProducer的request方法就可以了.经过调试该方法调用的fastpath();

  void fastpath() {
            final long endIndex = this.endOfRange + 1L;
            final Subscriber<? super Integer> childSubscriber = this.childSubscriber;
            for (long index = currentIndex; index != endIndex; index++) {
                if (childSubscriber.isUnsubscribed()) {
                    return;
                }
                childSubscriber.onNext((int) index);
            }
            if (!childSubscriber.isUnsubscribed()) {
                childSubscriber.onCompleted();
            }
        }

从该方法知道,用一个for循环,每次自增1,也就是index++的来调用onNext方法.

10,Repeat,代码如下

 Observable.range(1, 2).repeat(3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("---- onCompleted ----" );
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("---- onError ----");
            }

            @Override
            public void onNext(Integer integer) {
                System.out.println("---- onNext ----" + integer);
            }
        });

输出结果如下:

---- onNext ----1
---- onNext ----2
---- onNext ----1
---- onNext ----2
---- onNext ----1
---- onNext ----2
---- onCompleted ----

repeat的源码涉及到后面的内容比较多,因此在这里先不讲,等把涉及到内容讲了,再回过头来分析.

11,timer,代码如下

   Observable.timer(2, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {
                System.out.println("---- onCompleted ----");
            }
            @Override
            public void onError(Throwable e) {
                System.out.println("---- onError ----");
            }
            @Override
            public void onNext(Long aLong) {
                System.out.println("---- onNext ----" + aLong);
            }
        });
        Thread.sleep(10000);

输出结果:

---- onNext ----0
---- onCompleted ----

测试代码这样调用的原因,可以参考Interval,我就不在赘述了.
源码分析:

public static Observable<Long> timer(long delay, TimeUnit unit) {
        return timer(delay, unit, Schedulers.computation());
    }

这里使用的是Schedulers.computation(),因此可以知道timer是在子线程执行的.
接着跟进代码就可以看到OnSubscribeTimerOnce类,看到该类的call

 @Override
    public void call(final Subscriber<? super Long> child) {
        Worker worker = scheduler.createWorker();
        child.add(worker);
        worker.schedule(new Action0() {
            @Override
            public void call() {
                try {
                    child.onNext(0L);
                } catch (Throwable t) {
                    Exceptions.throwOrReport(t, child);
                    return;
                }
                child.onCompleted();
            }
        }, time, unit);
    }

在这里就可以看到timer的onNex是在调度器里面调用的.

好了讲到这里除了repeat的源码没有分析之外,其他创建Observable的方法以及源码都基本分析完了.下面接着讲的就是变换操作了.