RxJava使用过的库 rxjava defer

ReactiveX通过使用可观察序列来编写异步和基于事件程序的库。它扩展了观察者模式以支持数据和/或事件序列，并增加了运算符，使您可以声明性地组合序列，同时抽象出对低级线程，同步，线程安全性，并发数据结构和非线程等事物的关注阻塞I / O。

• defer
  直到有订阅者才创建observable，并且为每个订阅者创建一个全新的observable。
  defer 操作符返回一个Observable，它调用ObservableSource工厂为每个订阅的新Observer创建一个ObservableSource。 也就是说，对于每个订户，订户观察的实际ObservableSource由工厂函数确定。
  示例代码：创建defer和just操作符。

private Observable<Long> defer = getDefer();
  private Observable<Long> just = getJust();
  
  public Observable getDefer() {
        return Observable.defer(new Callable<ObservableSource<Long>>() {
            @Override
            public ObservableSource<Long> call() throws Exception {
                return getJust();
            }
        });
    }

	  private Observable getJust() {
        return Observable.just(System.currentTimeMillis());
    }

	public void subscribe() {
        just.subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long o) throws Exception {
                System.out.println("just" + o);
            }
        });

	 defer.subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long o) throws Exception {
                System.out.println("defer" + o);
            }
        });
    }

测试代码

@Test
    public void testDefer() {
        Defer defer = new Defer();
        defer.subscribe();
        sleep(100);
        defer.subscribe();
        sleep(100);
        defer.subscribe();
    }

打印结果：

just1553737935714
 defer1553737935730
 just1553737935714
 defer1553737935840
 just1553737935714
 defer1553737935949

defer每次订阅都会得到一个全新的数据，在某些情况下，直到最后订阅发生时，才生产Observable，确保数据是最新的。而just每次等到的数据都是一样的，说明just在每次订阅前不会得到最新的数据。

延迟Observer允许您推迟或延迟ObservableSource中的发射项，直到Observer订阅ObservableSource为止。 这允许Observer轻松获取序列的更新或刷新版本。

• interval

创建一个按固定时间间隔发射整数序列的Observable。

inteirval操作符返回一个observable，他按固定的时间间隔发射一个无限递增的整数序列

inteirval重载四个方法。

//初始延时时间，间隔时间，表示时间的单位，调度程序

Observable<Long> interval(long, long, TimeUnit)

//初始延时时间，间隔时间，表示时间的单位，调度程序

Observable<Long> interval(long, long, TimeUnit, Scheduler)

//间隔时间，表示时间的单位，

Observable<Long> interval(long, TimeUnit)

//间隔时间，表示时间的单位，调度程序

Observable<Long> interval(long, TimeUnit, Scheduler)

实例代码（1）：

public void interval() {
        Observable.interval(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        System.out.println(aLong);
                    }
                });
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

创建一个按固定时间间隔发射整数序列的Observable。上述代码中，每个1s中发送一个整型数据，从0到9截止。

实例代码（2）：

public void intervalInitialDelay() {
        Observable.interval(10, 1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        System.out.println(aLong);
                    }
                });
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

延迟十秒钟后，每个1s发送整型数据，到9截止。

• timer

创建一个observable，他在一个给定的延迟后发射一个特殊的值0

实例代码：

public void timer(){
        Observable.timer(5, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        System.out.println(aLong);
                    }
                });

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

10s中后发射一个数据，该数据为0。

timer操作符创建一个在给定的时间段之后返回一个特殊值的Observable。

timer返回一个Observable，他在延迟一段时间后发射一个简单的数字0，timer操作符默认在computation调度器上执行。