簡介
一個可觀測的序列來組成異步的、基於事件的程序的庫。（簡單來說：它就是一個實現異步操作的庫）
GitHub地址：https://github.com/ReactiveX/Rxjava
本文得目的
簡單解析RXJava原理，RXJava的被觀察者，觀察者，發射器簡單實現，最終完成以下代碼
- 操作符create創建被觀察者
- 轉換符map實現字符串轉換
- subscribeOn 線程池轉換
- observeOn主線程轉換
private void test() {
//創建
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) {
emitter.onNext("125");
emitter.onComplete();
}
});
//map方法
observable.map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
Log.d(TAG, "--apply--" + s+ "---" + Thread.currentThread().getName());
return Integer.parseInt(s);
}
}).subscribeOn()//map方法在線程池中調用
.observeOn()//主線程中調用
.subscribe(new Observer<Integer>() { //處理結果
@Override
public void onSubscribe(Disposeble d) {
Log.d(TAG, "onSubscribe " + d + "---" + Thread.currentThread().getName());
}
@Override
public void onNext(Integer s) {
Log.d(TAG, "onNext " + s+ "---" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError " + e+ "---" + Thread.currentThread().getName());
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete "+ "---" + Thread.currentThread().getName());
}
});
}
具體實現
- 創建被觀察者
//創建
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) {
emitter.onNext("125");
emitter.onComplete();
}
});
create是在Observable中一個靜態方法
//創建被觀察者
public static<T> Observable<T> create(ObservableOnSubscribe<T> observable) {
return new ObservableCreate(observable);
}
create方法中，傳遞了一個ObservableOnSubscribe接口，這個接口包含了subscribe方法
public interface ObservableOnSubscribe<T> {
void subscribe(ObservableEmitter<T> emitter);
}
ObservableOnSubscribe這接口中，傳遞了一個ObservableEmitter接口
public interface ObservableEmitter<T> {
//發出正常值信號
void onNext(T value);
//發出一個Throwable異常信號
void onError(Throwable throwable);
//發出完成的信號
void onComplete();
}
- 創建觀察者
public interface Observer<T> {
void onSubscribe(Disposeble d);
void onNext(T t);
void onError(Throwable e);
void onComplete();
}
- 發射器（鏈接被觀察者與觀察者） 這裏就是聯動觀察者與被觀察者的主要方法
//發射器綁定
public void subscribe(Observer observer) {
subscribeActual(observer);
}
聯動的具體實現
public class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<>(observer);
observer.onSubscribe(parent); //通知觀察者訂閱成功
try {
source.subscribe(parent);
} catch (Exception e) {
e.printStackTrace();
parent.onError(e);
}
}
static final class CreateEmitter<T> implements ObservableEmitter<T>, Disposeble {
final Observer<? super T> observer;
private boolean bool;
public CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T value) {
if(!bool){
observer.onNext(value); //observer === MapObserver
}
}
@Override
public void onError(Throwable throwable) {
if(!bool) {
observer.onError(throwable);
}
}
@Override
public void onComplete() {
if(!bool) {
observer.onComplete();
}
}
@Override
public void dispose(boolean bool) {
this.bool = bool;
}
@Override
public boolean isDisposed() {
return bool;
}
}
}
map聯動具體實現
public class ObservableMap<T, R> extends Observable<R> {
protected final Observable<T> source;
final Function<? super T, ? extends R> function;
public ObservableMap(Observable<T> source, Function<? super T, ? extends R> function) {
this.function = function;
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super R> observer) {
source.subscribe(new MapObserver<>(observer, function));
}
//觀察者
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U>{
final Function<? super T, ? extends U> mapper;
public MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
U apply = mapper.apply(t);
actual.onNext(apply);
}
}
}
線程池方法具體實現
public class ObservableSubscribeOn<T, R> extends Observable<R> {
protected final Observable<T> source;
private static ExecutorService executorService = Executors.newCachedThreadPool();
public ObservableSubscribeOn(Observable<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super R> observer) {
//從新包裝observer
final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
//告訴下游觀察者訂閱成功
observer.onSubscribe(parent);
executorService.submit(new Runnable() {
@Override
public void run() {
source.subscribe(parent);
}
});
}
static final class SubscribeOnObserver<T> implements Observer<T>, Disposeble{
final Observer<? super T> actual;
Disposeble<T> disposeble;
public SubscribeOnObserver(Observer<? super T> actual) {
this.actual = actual;
}
@Override
public void dispose(boolean bool) {
this.disposeble.dispose(bool);
}
@Override
public boolean isDisposed() {
return this.disposeble.isDisposed();
}
@Override
public void onSubscribe(Disposeble d) {
this.disposeble = d;
}
@Override
public void onNext(T t) {
this.actual.onNext(t);
}
@Override
public void onError(Throwable e) {
this.actual.onError(e);
}
@Override
public void onComplete() {
this.actual.onComplete();
}
}
}
主線程聯動具體實現
public class ObservableObserveOn<T> extends Observable<T> {
protected final Observable<T> source;
public ObservableObserveOn(Observable<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
ObserverOnObserver<T> parent = new ObserverOnObserver<>(observer);
source.subscribe(parent);
}
//包裝下游觀察者，並關聯onNext,..... 放入主線程中執行
static final class ObserverOnObserver<T> implements Observer<T>, Disposeble {
final Observer<? super T> actual;
Disposeble disposeble;
private Handler handler;
ObserverOnObserver(Observer<? super T> actual) {
this.actual = actual;
handler = new Handler(Looper.getMainLooper());
}
@Override
public void dispose(boolean bool) {
this.disposeble.dispose(bool);
}
@Override
public boolean isDisposed() {
return this.disposeble.isDisposed();
}
@Override
public void onSubscribe(Disposeble d) {
this.disposeble = d;
actual.onSubscribe(d);
}
@Override
public void onNext(final T t) {
handler.post(new Runnable() {
@Override
public void run() {
actual.onNext(t);
}
});
}
@Override
public void onError(final Throwable e) {
handler.post(new Runnable() {
@Override
public void run() {
actual.onError(e);
}
});
}
@Override
public void onComplete() {
handler.post(new Runnable() {
@Override
public void run() {
actual.onComplete();
}
});
}
}
}
一個簡單的rxjava就具體實現了，詳細請參考demo demo下載地址