RxJava is a library of asynchronous, event based programs that use observable sequences on the Java VM. In short, it's the asynchronous operation tool library. It can be used to keep the code simple when it comes to complex asynchronous functions.
RxJava uses the Observer mode. The observable and the Observer implement the subscription relationship through the subscription. Let's write a simple example first. To illustrate their relationship
/*
* A simple example
*/
private void SimpleExample() {
getObservable()
//Upstream, the thread of the observed is io thread
//Multiple settings valid for the first time
.subscribeOn(Schedulers.io())
//Downstream, the thread of observer is UI thread
//It can be set multiple times, and the thread can be switched each time
.observeOn(AndroidSchedulers.mainThread())
//Subscribe
.subscribe(getObserver());
}
/**
* Three ways to create an observer
* @return
*/
private Observable<String> getObservable() {
Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
observableEmitter.onNext("cricket");
observableEmitter.onNext("football");
observableEmitter.onComplete();
}
});
return observable;
//The second way is through fromXXX
// return Observable.fromArray("cricket","football");
//The third way is just
// return Observable.just("cricket", "football");
}
/**
* Observer
* @return
*/
private Observer<String> getObserver() {
return new Observer<String>() {
/**
* This will be called first
* Disposable Object call dispose() method can cut off the direct connection with the observed, and no data will be received after cutting off
* @param d
*/
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, " onSubscribe : " + d.isDisposed());
}
@Override
public void onNext(String value) {
Log.d(TAG, " onNext : value : " + value);
}
/**
* onError And the onComplete() method are mutually exclusive. An event stream is mutually exclusive
* Cannot send both the onError event and the onComplete event
* @param e
*/
@Override
public void onError(Throwable e) {
Log.d(TAG, " onError : " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, " onComplete");
}
};
}Output results:
onNext : value : cricket
onNext : value : football
onCompletemap operator
The map operator can convert the data type emitted by the observer, such as Integer to String, as follows:
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer + "launch";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG, "value=" + value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete");
}
});Output results:
value=1launch
value=2launch
value=3launch
onCompleteflatmap, concatmap operators
Data conversion of flatmap and concatmap
/**
* concatmap flatmap Use concatmap to ensure order
* Convert to observable < T >
*/
public void Example04() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
return Observable.just("I am value"+integer+"");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, s);
}
});
}Output results:
I am value1
I am value2
I am value3zip operator
zip can synthesize two observers into one observer object, as shown in the following example
/**
* zip Use of operators
* Less pipes shall prevail
*/
public void Example05() {
//Create an observed
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.io());
//Create another observed
Observable<String> observable1=Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
e.onNext("A");
e.onNext("B");
e.onComplete();
}
}).subscribeOn(Schedulers.io());
Observable.zip(observable, observable1, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String s) throws Exception {
Log.i(TAG,"apply"+integer+s);
return integer+s;
}
}).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG,value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG,"onComplete");
}
});
}Printed log
04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply1A
04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply2B
04-04 19:36:46.428 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 1A
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 2B
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: onComplettake operator
Use the take operator to limit the number of data to be sent. Only the number of requested data will be sent. For example, there are 5 data to be sent below, but only 3 data will be sent using the take operator
private void test() {
getObservable()
// Thread of the observed
.subscribeOn(Schedulers.io())
// Observer thread
.observeOn(AndroidSchedulers.mainThread())
//Send only 3
.take(3)
.subscribe(getObserver());
}
private Observable<Integer> getObservable() {
//Here are five data
return Observable.just(1, 6, 3, 4, 5);
}
private Observer<Integer> getObserver() {
return new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, " onSubscribe : " + d.isDisposed());
}
@Override
public void onNext(Integer value) {
Log.d(TAG, " onNext value : " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, " onError : " + e.getMessage());
}
@Override
public void onComplete() {
Log.d(TAG, " onComplete");
}
};
}Print log
onNext value : 1
onNext value : 6
onNext value : 3
onCompleteThis section will cover this first, and the next section will cover other operators.