目录
github代码地址
1、代码调用流程图
从下图中我们可看到:
1、调用create()方法会new 一个ObservableOnSubscribe对象,并将这个对象传到了ObservableCreate类中;
2、调用subscribe()订阅时,我们会创建一个Observer对象,并且穿给CreateEmitter类中;
3、然后,调用subscribe()会最后调用:
ObservableCreate_subscribeActual()
----->ObservableOnSubscribe_subscribe()
----->Emitter_onNext()
----->Observer_onNext()
4、这样我们Create()方法中的onNext()中的值,就传到了Observer中onNext()方法中。
1.1、create()
1.2、subscribe()
2、代码
2.1、结构目录
2.2、代码一
YoObservableSource--->YoObservable--->YoObservableCreate
它们三者是继承关系。
public interface YoObservableSource<T> {
void subscribe(YoObserver<? super T> yoObserver);
}
----------------------------------------------------------------------------
public abstract class YoObservable<T> implements YoObservableSource<T> {
@Override
public void subscribe(YoObserver<? super T> yoObserver) {
subscribeActual(yoObserver);
}
public static YoObservable create(YoObservableOnSubscribe source) {
return new YoObservableCreate(source);
}
protected abstract void subscribeActual(YoObserver<? super T> observer);
}
----------------------------------------------------------------------------
public class YoObservableCreate<T> extends YoObservable<T> {
private final YoObservableOnSubscribe<T> source;
public YoObservableCreate(YoObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(YoObserver<? super T> observer) {
YoEmitter emitter = new YoCreateEmitter(observer);
source.subscribe(emitter);
}
static final class YoCreateEmitter<T> implements YoEmitter<T> {
final YoObserver<? super T> observer;
YoCreateEmitter(YoObserver<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
void dispose() {
// 取消订阅
}
@Override
public boolean isDisposed() {
return false;
}
}
}
2.3、代码二
YoEmitter YoObservableOnSubscribe YoObserver
public interface YoEmitter<T> {
void onNext(T value);
void onError(Throwable error);
void onComplete();
boolean isDisposed();
}
-------------------------------------------------------------------------
public interface YoObservableOnSubscribe<T> {
void subscribe(YoEmitter<T> emitter);
}
-------------------------------------------------------------------------
public interface YoObserver<T> {
void onSubscribe();
void onNext(T t);
void onError(Throwable e);
void onComplete();
}
3、输出
3.1、原生输出
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Throwable {
log("开始发送消息!");
e.onNext("A");
e.onNext("B");
e.onNext("C");
e.onComplete();
}
}).doOnNext(s -> log("发送消息:" + s));
observable.subscribe(new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
log("我刚被订阅上,开始初始化工作!");
}
@Override
public void onNext(@NonNull String s) {
log("我接收到:" + s);
}
@Override
public void onError(@NonNull Throwable e) {
log("错误:" + e.getMessage());
}
@Override
public void onComplete() {
log("接受完成!");
}
});
//输出结果
main:我刚被订阅上,开始初始化工作!
main:开始发送消息!
main:发送消息:A
main:我接收到:A
main:发送消息:B
main:我接收到:B
main:发送消息:C
main:我接收到:C
main:接受完成!
3.2、手写输出
YoObservable yoObservable = YoObservable.create(new YoObservableOnSubscribe<String>() {
@Override
public void subscribe(YoEmitter<String> e) {
log("发送消息:A");
e.onNext("A");
log("发送消息:B");
e.onNext("B");
log("发送消息:C");
e.onNext("C");
e.onComplete();
}
});
yoObservable.subscribe(new YoObserver<String>() {
@Override
public void onSubscribe() {
log("我刚被订阅上,开始初始化工作!");
}
@Override
public void onNext(String s) {
log("我接收到:" + s);
}
@Override
public void onError(@NonNull Throwable e) {
log("错误:" + e.getMessage());
}
@Override
public void onComplete() {
log("接受完成!");
}
});
//输出
main:发送消息:A
main:我接收到:A
main:发送消息:B
main:我接收到:B
main:发送消息:C
main:我接收到:C
main:接受完成!