rxjava是一个在jvm上基于事件流实现异步操作的库
举一个简单的例子：
顾客去饭店吃饭
1.进饭店 坐下餐桌 叫服务员 点餐:餐点1 餐点2 餐点3 (顾客 是被观察者(Observable 主要是产生并发送事件)
2.服务员通知后厨 并将顾客点的餐点给到后厨 （服务员subscrible 通过订阅来连接被观察者Observable和观察者Observer)
3.后厨接收服务员发送的顾客点的餐点 ，并按照顺序一一将餐点制作出来， 并最终送到顾客桌上(后厨 是观察者(Observer)主要是用于接收被观察者发射的事件并定义处理相关事件的行为))
因此在rxjava中主要以下几个基本的概念:
1.被观察者Observable 用于生产并发送事件
2.观察者Observer 用于接收被观察者发射的事件 并定义了接收处理被观察者发射的事件的行为
3.subscrible 通过subscrible来连接被观察者和观察者 使他们之间产生联系
4.事件Event 被观察者Observable 和观察者Observer之间沟通的载体
因此我们使用rxjava的步骤就是：
1.创建Observable 被观察者对象 在上游生产相应的Event事件
2.创建观察者Observer对象 并定义响应上游Obervable发射的事件行为
3.通过subscribe 连接被观察者Observable 和观察者Observer
在Rxjava中被观察者 观察者 subscribe()方法 这三者缺一不可 只有使用了subscribe()方法被观察者才会开始发送数据这一点非常的重要!!
对于一个正常的事件序列来说在Rxjava中的调用顺序是(Observable发射的数据在下游有观察者通过subscribe()方法进行订阅):
Observer onSubscribe()上下游产生订阅关系 --> Observable subscribe()发射数据 --> Observer onNext(T) 接收并响应数据 --> Observer onComplete() / onError(E) 响应事件流正常结束或者出现错误的通知
使用方式一，常规流程使用:
//1.创建Obervable被观察者对象 生产相应的事件
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
//ObservableEmitter 事件发射器
//通过ObservableEmitter来定义相应的事件并发送给观察者
//被观察者可以发送无数个next事件 同时观察者也可以接收无数个next事件
e.onNext("Hello");
e.onNext("Rxjava");
e.onNext("我来了!");
//当被观察者发送了一个complete事件后被观察者在complete事件之后的事件将会继续发送
//但观察者接收到complete事件后将不再接收任何事件
//另外被观察者可以不发送complete事件
e.onComplete();
//当被观察者发送了一个error事件后被观察者在error事件之后的事件将会继续发送
//但观察者接收到error事件后将不再接收任何事件
//另外被观察者可以不发送error事件
// e.onError(new Throwable("产生error事件"));
//注意:complete事件和error事件时互斥的 即它们在一个事件序列中只能有一个
//同时complete和error是唯一它们只能有一个
}
});
//创建被观察者的变种
//1.通过just(T...)直接将传入的参数依次发送出来
/**
* 本质就是依次调用了:
* onNext("Hello");
* onNext("Rxjava");
* onNext("我来了!");
* onComplete();
*/
Observable<String> observablejust = Observable.just("Hello", "Rxjava", "我来了just!");
//2.通过FromArray(T...)/ fromIterable(Iterable i) 拆分成具体对象后依次发射出来
/**
* 本质上依次调用
* onNext("Hello");
* onNext("Rxjava");
* onNext("我来了from!");
* onComplete();
*/
String[] strArray = {"Hello","Rxjava","我来了from!"};
Observable<String> observableFrom = Observable.fromArray(strArray);
ArrayList arrayList = new ArrayList();
arrayList.add("Hello");
arrayList.add("Rxjava");
arrayList.add("我来了fromarraylist!");
Observable observablefromarraylist = Observable.fromIterable(arrayList);复制代码//2.创建观察者对象
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
//当观察者接收事件前首先会调用onSubscribe方法
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String value) {
//当被观察者生产next事件同时观察者接收到next事件时会调用该方法进行响应
Log.d(TAG, "onNext: " + value);
}
//当被观察者生产error事件同时观察者接收到error事件会调用该方法进行响应
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: " + e.getMessage());
}
//当被观察者生产complete事件同事观察者接收到complete事件时会调用该方法进行响应
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
};
//创建观察者对象的变种
//创建Subscriber对象来实现
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onSubscribe(Subscription s) {
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.d(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable t) {
Log.d(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
};复制代码//3.通过subscribe 订阅来连接被观察者和观察者
observable.subscribe(observer);
// observablejust.subscribe(observer);
// observableFrom.subscribe(observer);
// observablefromarraylist.subscribe(observer);复制代码使用方式二:
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
Log.d(TAG, "subscribe: ");
e.onNext("Hello");
e.onNext("Rxjava");
e.onNext("我来了!");
e.onComplete();
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe: ");
}
@Override
public void onNext(String value) {
Log.d(TAG, "onNext: " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
});
//注：整体的方法调用顺序是观察者的onSubscribe() -> 被观察者的subscribe() -> 观察者的onNext() .. -> 观察者的onComplete() 复制代码对于Observable的subscribe方法有多个重载的方法：
方法一no parameters: 表示观察者不对被观察者发送的任何事件(next,complete,error)做出响应 但是被观察者还是可以继续发送事件
//观察者不响应任何被观察者发送的任何事件但是被观察者是可以继续发送事件
//调用顺序:被观察者 subscribe()
observable.subscribe();复制代码方法二:表示观察者只对被观察者发送的next事件进行响应
//观察者只响应被观察者发送的next事件，当接收到next事件时会调用Consumer的accept方法
//但是被观察者还是可以发送任何事件的
//调用顺序：被观察者 subscribe() -> 观察者 accept()(next事件)
Observable.just("Hello","Rxjava","我来了!").subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
});复制代码方法三：表示观察者只对被观察者发送的next事件和error事件进行响应
//观察者只响应被观察者发送的next事件 error事件，当接收到被观察者发送的
//next事件和error事件会调用Consumer的accept方法
//但是被观察者还是可以发送任何事件的
//调用顺序：被观察者 subscribe() -> 观察者 accept()(next) -> 观察者 accept()(error)
Observable.fromArray(new String[]{"Hello","Rxjava","我来了!"}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.d(TAG, "accept: " + throwable.getMessage());
}
});复制代码方法四:表示观察者只对被观察者发送的next事件，error事件以及complete事件进行响应
//观察者对被观察者发送的next事件 error事件 complete事件都做出响应
//调用方式:被观察者 subscribe() -> 观察者 Consumer accept() (next) / 观察者 Consumer accept() (error) Action run() (complete)
observable.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.d(TAG, "accept: " + throwable.getMessage());
}
}, new Action() {
@Override
public void run() throws Exception {
Log.d(TAG, "run: complete");
}
});复制代码方法五:表示观察者只对被观察者发送的next事件， error事件， complete事件 以及onSubscribe事件进行响应
//观察者响应被观察者的next error complete事件同时会响应onSubscribe
//方法调用顺序:观察者Consumer accept(Disposable) -> 被观察者 subscribe() -> 观察者Consumer accept() (next) accept() (error) / Action run() (complete)
observable.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "accept: " + s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.d(TAG, "accept: " + throwable.getMessage());
}
}, new Action() {
@Override
public void run() throws Exception {
Log.d(TAG, "run: complete");
}
}, new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
Log.d(TAG, "accept: onsubscribe");
}
});复制代码方法六：表示观察者对被观察者发送的任何事件都做出响应
observable.subscribe(observer);复制代码观察者和被观察者之间的联系可以采用Disposable的dispose()方法进行中断联系
//通过Disposable对象来中断观察者和被观察者之间的联系
Observable.just(1,2,3,4).subscribe(new Observer<Integer>() {
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe: " + d.isDisposed());
//赋值给成员变量 mDisposable
mDisposable = d;
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "onNext: " + value);
if (value > 2){
//调用dispose中断观察者和被观察者之间的联系
mDisposable.dispose();
}
Log.d(TAG, "onNext: isDispose" + mDisposable.isDisposed());
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: ");
}
});复制代码以上就是我们对于Rxjava的基本概念的一些基本认识，rxjava是一个设计非常巧妙的库，而且现在在Android开发中rxjava+retrofit 以成为的标配因此我们非常有必要学习rxjava!
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
