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

6, from,
从create得知,如果我们的消息源有多个时,我们要多次调用onNext,Subscriber才能全部收到所有信息,而通过from来创建,我们则不需要自己调用onNext,rxjava会自动为我们调用了.
代码如下:

  String[] values = new String[]{"1", "2", "3"};
        Observable.from(values).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("---- onCompleted ----");
            }

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

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

运行结果如下:

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

从这里看我们并没有调用onNext,onCompleted.但是我们却可以收到对应的信息,from为我们做了什么呢?
源码分析如下:

    public static <T> Observable<T> from(T[] array) {
        // 这里判断我们传入的数组是否为空
        int n = array.length;
        // 如果为空则调用empty创建Observable,这里可以参考之前分析的empty方法
        if (n == 0) {
            return empty();
        } else
        // 这里just方法下面再讲
        if (n == 1) {
            return just(array[0]);
        }
        // 如果传入的数组的长度>1的时候这调用该方法
        return create(new OnSubscribeFromArray<T>(array));
    }

去看一下OnSubscribeFromArray内部:

public final class OnSubscribeFromArray<T> implements OnSubscribe<T> {
    final T[] array;
    public OnSubscribeFromArray(T[] array) {
       // 这里可以知道该类会保存一份我们传入的数组元素
        this.array = array;
    }
    ... 忽略部分
    }

接着我们看到该类的call方法:

@Override
    public void call(Subscriber<? super T> child) {
        child.setProducer(new FromArrayProducer<T(child, array));
    }

这里我们先看child.setProducer方法做了什么:

    public void setProducer(Producer p) {
        ... 忽略部分
        // 从这里可以看出该方法是一个递归调用
        if (passToSubscriber) {
            subscriber.setProducer(producer);
        } else {
        // 我们目前只需要看到这一部分就可以了
        // 从这里看到这个调用的是Producer 里面的request方法
            if (toRequest == NOT_SET) {
                producer.request(Long.MAX_VALUE);
            } else {
                producer.request(toRequest);
            }
        }
    }

从源码可以看出该方法里面调用了FromArrayProducer里面的request方法,好了我们现在去看一下该方法做了什么.

  @Override
        public void request(long n) {
            ... 忽略部分
            // 这里判断根据出传入的n来判断是调用fastPath,还是slowPath.
            // 经过我的几次调试该方法都是调用fastPath的
            if (n == Long.MAX_VALUE) {
                if (BackpressureUtils.getAndAddRequest(this, n) == 0) {
                    fastPath();
                }
            } else
            if (n != 0) {
                if (BackpressureUtils.getAndAddRequest(this, n) == 0) {
                    slowPath(n);
                }
            }
        }

通过几次调试发现该方法都是调用fastPath的,该方法的源码如下:

 void fastPath() {
            final Subscriber<? super T> child = this.child;

            for (T t : array) {
                if (child.isUnsubscribed()) {
                    return;
                }

                child.onNext(t);
            }

            if (child.isUnsubscribed()) {
                return;
            }
            child.onCompleted();
        }

看到该方法应该就很清楚from做了什么吧.它内部已经循环帮我调用onNext方法了,并在最后调用onCompleted.跟运行结果一致.

7,interval
该方法演示的时候有点麻烦,我用的junit来测试的,代码如下:

       Observable.interval(1, 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
---- onNext ----1
---- onNext ----2
---- onNext ----3
---- onNext ----4
---- onNext ----5
---- onNext ----6
...

interval是每隔我们指定的时间就调用一次,因为我是用过junit运行的,如果线程不阻塞,还没等到Observable输出程序就退出了.
源码分析如下:

  public static Observable<Long> interval(long interval, TimeUnit unit) {
  // 在这里涉及到调度器,因为我们还没讲到该内容,在这里我们只需要知道
  // interval的运行不是在本线程调用即可
        return interval(interval, interval, unit, Schedulers.computation());
    }

从上面的源码知道interval是通过调度器来运行的Schedulers.computation(),这也是我们阻塞了线程,程序还能输出的原因了.
继续看interval内部的源码:

 public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
       return create(new OnSubscribeTimerPeriodically(initialDelay,period,unit,scheduler));
    }

看到OnSubscribeTimerPeriodically类里面的call方法:

    @Override
    public void call(final Subscriber<? super Long> child) {
        final Worker worker = scheduler.createWorker();
        child.add(worker);
        worker.schedulePeriodically(new Action0() {
            long counter;
            @Override
            public void call() {
                try {
                // 看到这里每次都调用onNext
                    child.onNext(counter++);
                } catch (Throwable e) {
                // 如果有异常就取消订阅
                    try {
                        worker.unsubscribe();
                    } finally {
                        Exceptions.throwOrReport(e, child);
                    }
                }
            }
            // 这里可以看到,该方法是定时调用的
        }, initialDelay, period, unit);
    }

通过该方法就很清楚,为什么interval为什么能一直输出了.这里涉及到调度器的内容,我们先不讲,只需要知道,它会在子线程里面调用onNext方法.这样也看到call的方法内,没有调用onCompleted也就是说,该方法除非去掉订阅,否则不会结束.

8,Just
代码如下:

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

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

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

运行结果如下:

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

just的用法和from的用法类似,区别的是,just传入多个参数,而from是直接传入数组的.在分析from源码的时候知道,如果传入from数组的长度为1的时候调用的just来创建的.
源码分析:

   public static <T> Observable<T> just(T t1, T t2, T t3) {
        return from((T[])new Object[] { t1, t2, t3 });
    }

从这里看到just传入多个参数的时候调用的还是from来创建的.
下面需要分析的just传入一个参数的时候:

public static <T> Observable<T> just(final T value) {
        return ScalarSynchronousObservable.create(value);
    }

得知底部是通过调用ScalarSynchronousObservable方法里面的call来调用的:

  protected ScalarSynchronousObservable(final T t) {
        super(new OnSubscribe<T>() {

            @Override
            public void call(Subscriber<? super T> s) {
                // setProducer已经在分析from的时候分析过了,这里就不再分析了
                s.setProducer(createProducer(s, t));
            }

        });
        this.t = t;
    }

底部是通过setProducer来调用的前面已经分析过该方法了这里就不再分析了.

接着看下面一段代码:

    String value = "1";
        Observable<String> observable = Observable.just(value);

        value = "1000";

        observable.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("---- onCompleted ----" );
            }

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

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

输出结果是1还是1000呢?可能很多人以为是1000,但是输出结果却是这样的:

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

为什么会这样呢?我们知道just一个参数的时候调用的是ScalarSynchronousObservable的call方法,看一下该类做什么:

  protected ScalarSynchronousObservable(final T t) {
        ... 忽略部分
        // 这里,保存了我们在just传进来的值,这也是为什么输出的一个旧的值
        this.t = t;
    }

遇到这种问题应该怎么解决呢? 在这里我们只想存在订阅者也就是调用subscribe方法是输出value 方式的值.大家还记得前面介绍defer方法吗?该方法就是在调用subscribe方法时才真正去创建Observable的实例,因此我们的代码可以这样写:

   String finalValue = "1";
    @Test
    public void testDefer3(){
        Observable observable = Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable call() {
                return Observable.just(finalValue);
            }
        });
        finalValue = "1000";
        observable.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("---- onCompleted ----");
            }

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

            }

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

这时候大家应该知道输出结果是什么了吧.
输出结果:

---- onNext ----1000
---- onCompleted ----

从上面也可以知道just会在内部保存创建的值,如果改值是普通类型,不是对象引用的时候,则会出现输出旧值的情况.通过defer就可以很好的解决该问题了.