Rxjava 源码学习

一：Observable.create
二：Observable.subscribe
三：自己写的demo 模拟这个调用过程

一：Observable.create

    Observable.create (
            // 自定义source
            new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(ObservableEmitter<String> emitter)           throws Exception {
                    // 发射器.onNext
                    emitter.onNext("AAA");
                }
            }
    )

二：Observable.subscribe

    // subscribe订阅过程 源码分析
    // Observable. subscribe
    .subscribe(
            // 自定义观察者
            new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });

因为刚刚初始化，即new 了一个ObservableCreate,且ObservableCreate是实现了Observale 的。所以这里调用Observale.subscribe 方法，会执行subscribeActual()方法，但这个方法是个抽象方法，所以会找到具体实现类。

当执行实现类里的subscribeActual方法时，如下两个方法得到执行：
observer.onSubscribe(parent); // 会执行 自定义观察者的onSubscribe

source.subscribe(parent); // 会执行自定义source里的subscribe方法

三：自己写的demo 模拟这个调用过程

1，MyObservable
public abstract class MyObservable {
private static final String TAG = “lcj MyObservable”;
public static MyObservable create (MyObservableOnSubscribe source) {
Log.i(TAG, “create”);
return new MyObservableCreate(source);
}
public final void subscribe(MyObserver<? super T> observer) {
Log.i(TAG, “subscribe”);
try {
subscribeActual(observer);
} catch (NullPointerException e) { throw e;
} catch (Throwable e) {
NullPointerException npe = new NullPointerException(“Actually not, but can’t throw other exceptions due to RS”);
npe.initCause(e);
throw npe;
}
}
protected abstract void subscribeActual(MyObserver<? super T> observer) throws Exception;
}

2，MyObservableCreate
public class MyObservableCreate extends MyObservable{
private static final String TAG = “lcj MyObservableCreate”;
final MyObservableOnSubscribe source;

public MyObservableCreate(MyObservableOnSubscribe source) {
    Log.i(TAG, "MyObservableCreate构造方法 start");
    this.source = source;
}

@Override
protected void subscribeActual(MyObserver observer) throws Exception {
    Log.i(TAG, "subscribeActual start");
    MyObservableEmitterImpl impl = new MyObservableEmitterImpl();
    observer.onSubscribe(impl);
    source.subscribe(impl);
}

}

3，MyObservableEmitter

4，MyObservableEmitterImpl
public class MyObservableEmitterImpl implements MyObservableEmitter{

@Override
public void setDisposable(String d) {

}

@Override
public void setCancellable(String c) {

}

@Override
public boolean isDisposed() {
    return false;
}

}

5，MyObservableImpl （写这个类，是想说明，这个类没有初始化，即使继承了Observable, 但是没有实例化，subscribeActual 也得不到执行）

6，MyObservableOnSubscribe
public interface MyObservableOnSubscribe {

void subscribe(MyObservableEmitter e) throws Exception;

}

7，MyObserver
public interface MyObserver {

void onSubscribe(T d);

void onNext(T t);

}

执行结果：