2016-9-9-CSDN博客

本文链接：https://blog.csdn.net/a90123/article/details/52489920
2016-9-9

1.rxjava使用场景

1.计时：
Observable.interval(0, 10, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return 60 - aLong;
                    }
                })
                .skipWhile(new Func1<Long, Boolean>() {
                    @Override
                    public Boolean call(Long aLong) {
                        return aLong >= 20;
                    }
                })
                .takeWhile(new Func1<Long, Boolean>() {
                    @Override
                    public Boolean call(Long aLong) {
                        return aLong >= 0;
                    }
                })
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("aLong = [" + aLong + "]");
                    }
                });
interval(long interval, TimeUnit unit): 每隔interval时间间隔后发射一次数据
interval(long initialDelay, long period, TimeUnit unit)：第一次延迟initialDelay时间发射数据，之后每隔period时间发射数据
skipWhile：返回true时，开始发射数据， 丢弃之前发射的数据
takeWhile：返回false时，停止发射数据，整个订阅完成（onComplete());
2. 多次点击检测
 Observable<Void> observable = RxView.clicks(view).share();
        observable.buffer(observable.debounce(200,TimeUnit.MILLISECONDS))
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<List<Void>>() {
                    @Override
                    public void call(List<Void> voids) {

                    }
                });
buffer()：会将observable 发射的item缓存起来，直到它的参数Observable发射一个item时，它会将之前缓存的都作为一个list发射出去
debounce:该item之后的一段时间内没有item发出，则发出该item，丢弃该item之前的数据
Publish：通过Publish操作符可以将一个普通的Observable转换为一个Connectable Observable。Connectable Observable 可以被多次订阅，被多个Subscriber共享Stream。但是和普通的Observable不同，它在被subscribe之后并不开始产生item，而需要在调用connect()之后才会产生item。
Connect：在Publish中已经提到，用来让Connectable Observable开始产生item。
Refcount：除了Connect，我们有另一种方式来让Connectable Observable 产生item，那就是Refcount，refCount会在第一个subscriber订阅之后自动connect，在最后一个subscriber unsubscribe之后自动disconnect。
Share：Share 其实就是publish().refCount();
3. 取数据先检查缓存的场景
final Observable<String> memory = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        if (memoryCache != null) {
            subscriber.onNext(memoryCache);
        } else {
            subscriber.onCompleted();
        }
    }
});
Observable<String> disk = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        String cachePref = rxPreferences.getString("cache").get();
        if (!TextUtils.isEmpty(cachePref)) {
            subscriber.onNext(cachePref);
        } else {
            subscriber.onCompleted();
        }
    }
});

Observable<String> network = Observable.just("network");

//主要就是靠concat operator来实现
Observable.concat(memory, disk, network)
.first()
.subscribeOn(Schedulers.newThread())
.subscribe(s -> {
    memoryCache = "memory";
    System.out.println("--------------subscribe: " + s);
});
4. 多个接口并发取完数据
//拼接两个Observable的输出，不保证顺序，按照事件产生的顺序发送给订阅者
private void testMerge() {
    Observable<String> observable1 = DemoUtils.createObservable1().subscribeOn(Schedulers.newThread());
    Observable<String> observable2 = DemoUtils.createObservable2().subscribeOn(Schedulers.newThread());

    Observable.merge(observable1, observable2)
            .subscribeOn(Schedulers.newThread())
            .subscribe(System.out::println);
}
5. 一个接口的请求依赖另一个API请求返回的数据
 NetworkService.getToken("username", "password")
    .flatMap(s -> NetworkService.getMessage(s))
    .subscribe(s -> {
        System.out.println("message: " + s);
    });
6. 防止连续点击
RxView.clicks(findViewById(R.id.btn_throttle))
    .throttleFirst(1, TimeUnit.SECONDS)
    .subscribe(aVoid -> {
        System.out.println("click");
    });
throttleFirst:该item是之后的一段时间内第一次发生的item，则发出该item，丢弃该时间内发生的其它item
7. 复杂的数据变换
Observable.just("1", "2", "2", "3", "4", "5")
    .map(Integer::parseInt)
    .filter(s -> s > 1)
    .distinct()
    .take(3)
    .reduce((integer, integer2) -> integer.intValue() + integer2.intValue())
    .subscribe(System.out::println);//9
map: 对Observable发射的每一项数据应用一个函数，转换数据
filter: 只把符合条件的数据发出
distinct：去除发射的重复数据
take: 只发射前几个数据
reduce: 对发射的所有数据应用给定的函数， 然后发射一个最终数据
8. 通过Observable的zip操作符把ResponseBody和url组合在一起(如下图)
zip:多个Observable都发射数据后, 把发射的数据组合在一起发射出去, 有一observable发射错误数据, 则不再组合数据,直接发射错误