Rxjava详解
Rxjava文章很多了，自学所用。如下链接解析的很好，本文写一下小demo实战。
http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2015/1012/3572.html#toc_1
基本概念：异步库，序列式编写，可线程控制
"a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。
异步原理
使用观察者模式
盗个图。。
简单的分析：
为何用？？？ 两个业务需求或两个动作之间如何连接？？？ 简单的方式是A中直接包括B对象，并调用。
弊端：产生紧耦合，A需要了解B的功能和方法并调用。A对应多种B时，A就要大量的调用。
观察者方案：A和B之间利用注册通知的方法进行业务交互。A（被观察者）提供注册方法（也可以取消注册），提供通知方法（在通知方法中调用B的统一接口update）。B（观察者）实现方法update。类似其他设计模式，便于派生多种不同的观察者，AB都设计抽象类。
举例子：在使用信用卡消费成功后，需要发送短信通知，发送微信通知，需要生成消费积分，产生抽奖次数。消费作为被观察者，在成功后发送通知给各个观察者，使观察者立刻执行自身业务。
Rxjava例子，先看为敬
Observable.from(folders)
.flatMap(new Func1<File, Observable<File>>() {
@Override
public Observable<File> call(File file) {
return Observable.from(file.listFiles());
}
})
.filter(new Func1<File, Boolean>() {
@Override
public Boolean call(File file) {
return file.getName().endsWith(".png");
}
})
.map(new Func1<File, Bitmap>() {
@Override
public Bitmap call(File file) {
return getBitmapFromFile(file);
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Bitmap>() {
@Override
public void call(Bitmap bitmap) {
imageCollectorView.addImage(bitmap);
}
});创建观察者
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onNext(Integer s) {
Log.e(tag, "Item: " + s);
}
@Override
public void onCompleted() {
Log.e(tag, "Completed!");
}
@Override
public void onError(Throwable e) {
Log.e(tag, "Error!");
}};不完整回调Action1:
Action1<String> onNextAction = new Action1<String>() {
// onNext()
@Override
public void call(String s) {
Log.d(tag, s);
}
};创建被观察者
Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。 RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则。
被观察者包括了很多自定义实现：from，just，map，flatmap，first，elementAt，filter等。这些实现中会自定义通知（即三个回调函数）的调用流程。
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Hi");
subscriber.onNext("Aloha");
subscriber.onCompleted();
}});form例子
String [] strings={"one","two"};
Observable.from(strings).subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(tag,"call from "+s);
}
});just例子
Converts two items into an Observable that emits those items. 将两个items放到一个Observable中，然后依次发送每个item。也可以是多个item，但是参数类型必须保持一致。
Observable.just(123,456).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(tag, "call "+integer);
}
});Map例子
String [] strings={"one","two"};
Observable.just(strings) // 输入类型 String数组
.map(new Func1<String[], String>() {
@Override
public String call(String[] sarray) { // 参数类型 String数组
StringBuffer ssum = new StringBuffer();
for (String s : sarray)
ssum.append(s);
return ssum.toString(); // 返回类型String
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) { // 参数类型 String
Log.i(tag, "call " + s);
}
});flatMap例子
Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger.
flatmap接收一个Observable，这个Observable发送一组item。在flatmap中将每个item转化成一个Observable，这个Observable汇总合并所有转化结果，最后再发送到观察者。
class Student{
private String name;
public String [] course;
public Student(String _name,String []_c){
name=_name;
course=_c;
}
}
Student [] student=new Student[2];
student[0]=new Student("小红",new String[]{"数学","英语","物理"});
student[1]=new Student("小明",new String[]{"地理","语文","化学"});
Observable.from(student)
.flatMap(new Func1<Student, Observable<String>>(){
@Override
public Observable<String> call(Student st) {
return Observable.from(st.course);
}
}).subscribe(new Observer<String>() {
@Override
public void onCompleted() {
Log.i(tag,"call onCompleted");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.i(tag,"call "+s);
}
}
);线程分配
在RxJava 中，Scheduler ——调度器，相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 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 主线程运行。
Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.map(mapOperator) // 新线程，由 observeOn() 指定
.observeOn(Schedulers.io())
.map(mapOperator2) // IO 线程，由 observeOn() 指定
.observeOn(AndroidSchedulers.mainThread)
.subscribe(subscriber); // Android 主线程，由 observeOn() 指定原理浅析
- Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
- @Override
- public void call(Subscriber<? super String> subscriber) {
- subscriber.onNext("Hello");
- subscriber.onCompleted();
- }});
扫一扫
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
