Rxjava详解

一,作用

RxJava的目的就是异步。RxJava的特点就是可以非常简便的实现异步调用，可以在逻辑复杂的代码逻辑中以比较轻易的方式实现异步调用。随着逻辑的复杂，需求的更改，代码可依然能保持极强的阅读性，在深入的使用过程中一定对这点深有体会。

二,添加依赖

io.reactivex.rxjava2:rxjava:2.0.4

io.reactivex.rxjava2:rxjava:2.0.4

三,关键api

Observable：在观察者模式中称为“被观察者”； Observer：观察者模式中的“观察者”，可接收Observable发送的数据； subscribe：订阅，观察者与被观察者，通过subscribe()方法进行订阅； Subscriber：也是一种观察者，在2.0中 它与Observer没什么实质的区别，不同的是 Subscriber要与Flowable(也是一种被观察者)联合使用，该部分内容是2.0新增的，后续文章再介绍。Obsesrver用于订阅Observable，而Subscriber用于订阅Flowable

四,回调方法

onComplete(): 事件队列完结时调用该方法。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。 onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。 onSubscribe()：RxJava 2.0 中新增的，传递参数为Disposable ，Disposable 相当于RxJava1.x中的Subscription,用于解除订阅。 注意：onComplete() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

五,线程调度,****Scheduler，**相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。

1,Schedulers.immediate():** 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。

2,Schedulers.newThread():** 总是启用新线程，并在新线程执行操作

3,Schedulers.io():** I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler,多数情况下 io() 比 newThread() 更有效率

4,Schedulers.computation()**: **计算所使用的 Scheduler,不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。

5,Android 还有一个专用的** **AndroidSchedulers.mainThread()****，它指定的操作将在 Android 主线程运行。

subscribeOn(): 指定Observable(被观察者)所在的线程，或者叫做事件产生的线程。 * observeOn(): 指定 Observer(观察者)所运行在的线程，或者叫做事件消费的线程。

Disposable*, 这个单词的字面意思是一次性用品,用完即可丢弃的。在RxJava中,用它来切断Observer(观察者)与Observable(被观察者)之间的连接，当调用它的dispose()方法时, 它就会将Observer(观察者)与Observable(被观察者)之间的连接切断, 从而导致Observer(观察者)收不到事件。

六,代码
///第二种方式,采用链式调用/
private void second() {
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("hello world");
e.onNext("第一次用");
e.onComplete();
}
}).subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: ");
}

        @Override
        public void onNext(String s) {
            Log.e(TAG, s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete");
        }
    });
}

/*
第三种方式,使用Consumer只接收发送信息/
private void third() {
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("hello world");
e.onNext("第一次用");
e.onComplete();
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
//表示我只在乎next发出的消息,也只接受这个消息
Log.e(TAG, s);
}
});
}

///第四种,调用Schedulers线程调度器/
private void four() {
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.e(TAG, "事件产生线程" + Thread.currentThread().getName());
e.onNext("hehe");

        }
    }).subscribeOn(Schedulers.io()) //事件产生的线程,也就是被观察者
            .observeOn(AndroidSchedulers.mainThread()) //时间消费的线程,也就是观察者
            .subscribe(new Consumer() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    Log.e(TAG, "接受到的结果" + s);
                    Log.e(TAG, "事件消费线程" + Thread.currentThread().getName());
                }
            });
}

/*
第五种,使用just直接出发onNext()
* 使用just( )，将为你创建一个Observable并自动为你调用onNext( )发射数据。
* 通过just( )方式 直接触发onNext()，just中传递的参数将直接在Observer的onNext()方法中接收到。*/
private void five() {
Observable.just("hello").subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, s);
}
});
}

///第六种,使用interval做定时器,/
private void six() {
//可用作定时器。即按照固定2秒一次调用onNext()方法。
Observable observable = Observable.interval(2, TimeUnit.SECONDS);
Observer observer = new Observer() {
@Override
public void onSubscribe(Disposable d) {
}

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, aLong.toString());
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onComplete() {

        }
    };
    SystemClock.sleep(6000);//睡眠6秒后，才进行订阅, 仍然从0开始，表示Observable内部逻辑刚开始执行
    observable.subscribe(observer);
}

/*
* //第七种,使用map将一种数据转换成另一种数据返回*/
private void seven() {
Observable.just("hello").map(new Function() {
@Override
public Integer apply(String s) throws Exception {
return s.length();
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
Log.e(TAG, "返回的数据 " + integer);
}
});
}

/*
第八种,使用filter将需要的数据筛选出来
* */
private void eight() {
lists.add("你好呵呵呵呵呵");
lists.add("开心哈哈哈哈");
Observable.just(lists).flatMap(new Function, ObservableSource>() {
@Override
public ObservableSource apply(List strings) throws Exception {
return Observable.fromIterable(strings);
}
}).filter(new Predicate