RxJava
是什么:异步
好处:
- 代码简洁可读性强
- 可随意的切换线程
最基本的使用方法
首先要在gradle文件中加入.jar文件
compile ‘io.reactivex:rxjava:1.2.7’
compile ‘io.reactivex:rxandroid:1.0.1’
要满足三个条件,(1)创建Observer观察者 (2)创建Observable被观察者 (3)Subscribe完成订阅。
下面我们来写一个最基本的功能。代码如下:
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Word");
subscriber.onCompleted();
}
}).subscribe(new Observer<String>() {
@Override
public void onCompleted() {
Log.d(TAG, "onCompleted: enter");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: s = " + s);
}
});
其中Observer可以这样写:
Action1<String> onNext = new Action1<String>() {
@Override
public void call(String s) {
Log.d(TAG, "call: s = " + s);
}
};
Action1<Throwable> onError = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Log.d(TAG, "throwable :");
}
};
Action0 onCompleted = new Action0() {
@Override
public void call() {
Log.d(TAG, "onCompleted: enter");
}
};
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Word");
subscriber.onCompleted();
}
}).subscribe(onNext,onError,onCompleted);
创建Observable的方法常用的为:
//这里的just(T...)将传如的参数依次发送出来;
Observable observable = Observable.just("Hello","Word","My","God");
String [] words = {"Hello","Word","My","God"};
Observable observable2 = Observable.from(words);
// just(T...) 与 from(T[])方法都是如下意思;
// onNext("Hello");
// onNext("Word");
// onNext("My");
// onNext("God");
上面的介绍中我们Rxjava默认事件的发生和消费都在同一个线程中,现在还只是一个同步的观察者模式。
Rxjava的线程控制;
因为Rxjava 默认情况下,事件发生与消费都在同一个线程中;那么这样的话根本就没起到异步的作用;
所以下面我们来介绍Rxjava的核心–线程控制 Scheduler(调度)
Rxjavay已经内置了几个Scheduler 如下:
Schedulers.immediate(): 直接在当前线程运行,这是默认的 Scheduler。
Schedulers.newThread(): 总是启用新线程,并在新线程执行操作。
Schedulers.io(): I/O 操作(读写文件、读写数据库、网络信息交互等)所使用的 Scheduler。行为模式和 newThread() 差不多,区别在于 io() 的内部实现是是用一个无数量上限的线程池,可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中,可以避免创建不必要的线程。
Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算,即不会被 I/O 等操作限制性能的操作,例如图形的计算。这个 Scheduler 使用的固定的线程池,大小为 CPU 核数。不要把 I/O 操作放在 computation() 中,否则 I/O 操作的等待时间会浪费 CPU。
另外, Android 还有一个专用的 AndroidSchedulers.mainThread(),它指定的操作将在 Android 主线程运行。
以上几种中最常用的是Schedulers.io()与AndroidSchedulers.mainThread()
有了以上这些线程就可以对事件的线程进行操作了。操作线程的方法有如下两种:
Observable.just("Hello", "Word", "My", "God")
//指定 subscribe() 发生在IO 线程;
.subscribeOn(Schedulers.io())
// 指定 Subscriber 的回调发生在主线程;
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.d(TAG, "call: s = " + s);
}
});
Rxjava最牛逼的地方 --变换;
所谓变化就是将事件序列中的对象或整个序列进行加工处理,转换成不同事件或事件序列。
API map() 和 flatMap()
map() 的转换是一对一的转换,
例子;
//输入string类型;
Observable.just("1234", "4567", "3345", "3567")
//转化成Integer类型;
.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return Integer.valueOf(s);
}
}).subscribe(new Action1<Integer>() {
//参数为Integer类型;
@Override
public void call(Integer integer) {
Log.d(TAG, "call: integer = " + integer);
}
});
flatMap() 的作用与map()有点相同,但是flatMap()是一对多的转换,他返回的是一个Observable对象,并且这个对象并不直接发送到Subscriber的方法回调中,而是等待激活。
Observable.just("1234", "4567", "3345", "3567")
//他返回的是一个Observable对象;
.flatMap(new Func1<String, Observable<Integer>>() {
@Override
public Observable<Integer> call(String s) {
return Observable.just(Integer.valueOf(s));
}
})
//为过滤操作符,只有满足条件的才进入下一步;
.filter(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer != 0;
}
})
//事物处理在io线程中完成;
.subscribeOn(Schedulers.io())
//结果在主线程中展现;
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
mText.setText("" + integer);
}
});