1.什么是Rxjava
作者给他的概括是"a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库），通俗来讲就是一个采用观察者模式设计的响应式编程框架，灵魂在于他所拓展的观察者模式和异步操作。
2.什么是观察者模式
一般而言，实现对一组数据的实时监控，常用的有两种方式，一种采用setListener这样的回调机制，另一种则是写一个轮询2秒钟去查看一下这组数据是否变化。但，其实还有另一种方式即观察者模式，观察者模式强调当被观察者数据改变时，被观察者会告知观察者，然后进行你想要的操作。实现如下：
1.新建被观察者接口：
public interface Observerable {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObservers();
}
2.新建观察者接口：
public interface Observer {
public void update(int edition,float cost);
}
3.实现被观察者接口：
public class MagazineData implements Observerable {
private List<Observer> mObservers;
private int edition;
private float cost;
public MagazineData() {
mObservers = new ArrayList<>();
}
@Override
public void registerObserver(Observer o) {
mObservers.add(o);
}
@Override
public void removeObserver(Observer o) {
int i = mObservers.indexOf(o);
if(i >= 0)
mObservers.remove(i);
}
@Override
public void notifyObservers() {
for(int i = 0; i < mObservers.size(); i++){
Observer observer = mObservers.get(i);
observer.update(edition, cost);
}
}
public void setInfomation(int edition,float cost){
this.edition = edition;
this.cost = cost;
//信息更新完毕，通知所有观察者
notifyObservers();
}
}
4.实现观察者接口：
public class Customer implements Observer {
private String name;
private int edition;
private float cost;
public Customer(String name){
this.name = name;
}
@Override
public void update(int edition, float cost) {
this.edition = edition;
this.cost = cost;
buy();
}
public void buy(){
System.out.println(name+"购买了第"+edition+"期的杂志，花费了"+cost+"元。");
}
}
5.代码实现：
public class Test { public static void main(String[] args) {
//创建被观察者
MagazineData magazine = new MagazineData();
//创建观察者
Observer customerA = new Customer("A");
//将观察者注册到被观察者中
magazine.registerObserver(customerA);
//更新被观察者中的数据，当数据更新后，会自动通知所有已注册的观察者
magazine.setInfomation(5, 12);
}
}
3.观察者Observer类介绍
1.Observer的创建：
Observer有两种创建方式一种是：
Observer observer = new Observer() {
@Override
public void onCompleted() {
//onCompleted在没有onNext方法后调用 调用后事件队列的完成
}
@Override
public void onError(Throwable e) {
//onError在处理事件中发生意外时调用 调用后事件队列的完成
}
@Override
public void onNext(String s) {
//onNext用来发送事件
}
};
第二种是：
Subscriber subscriber =new Subscriber() {
@Override
public void onStart() {
//在队列运行前进行数据的初始化，不包括UI部分
}
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
}
};
5.被观察者Observable类介绍*
1.创建被观察者
Observable<string> Observable= Observable.create(newObservable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("World");
subscriber.onCompleted();
}
});
2.订阅观察者
Observable.subscribe(observer);
调用订阅后观察者就会根据被观察者call里的情况调用相应的方法
这里看一下subscribe的源码
public final Subscription subscribe(final Observer observer) {
if(observer instanceof Subscriber) {
return subscribe((Subscriber)observer);
}
return subscribe(new Observer<T> Subscriber(observer));
}
简单来说就是如果传过来的是个Observer类就会把它转化成Subscriber类，然后subscribe是什么呢？
static Subscription subscribe(Subscriber subscriber, Observable observable) {
if (subscriber == null) {
throw new IllegalArgumentException("subscriber can not be null");
}
if (observable.onSubscribe == null) {
throw new IllegalStateException("onSubscribe function can not be null.");
}
//先调用onStart进行数据初始化
subscriber.onStart();
if (!(subscriber instanceof SafeSubscriber)) {
//目测是确保onError与onCompletedliang两个方法调用后禁止调用其他方法
subscriber = new SafeSubscriber(subscriber);
}
try {
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
} catch (Throwable e) {
//catch内容先别管
}
return Subscriptions.unsubscribed();
}
然后是try里的这两句
hook.onSubscribeStart(observable,observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
发现hook.onSubscribeStart(observable,observable.onSubscribe)返回一个onSubscribe，
hook.onSubscribeReturn(subscriber)返回一个subscription所以可以简化为
onSubscribe.call(subscriber);
return subscription;
而这个call就是你new Observable时重写的方法。总结一下就是这部分的代码相当于最基础的观察者模式中的
magazine.registerObserver(customerA);
注册订阅部分，而新建观察者和被观察者的代码相当于之前实现接口的代码
