2.1. 创建Observable：

创建Observable用的是Observable.create(ObservableOnSubscribe<T> source)方法。这个方法的参数是ObservableOnSubscribe：

public interface ObservableOnSubscribe<T> {

    /**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;
}

ObservableOnSubscribe是一个函数式接口，有唯一的方法subscribe，参数是ObservableEmitter<T> e。ObservableEmitter是一个继承了Emitter的接口，接口Emitter里定义了onNext、onError、onComplete等方法，和Observer（观察者）的方法相对应。

public interface Emitter<T> {

    /**
     * Signal a normal value.
     * @param value the value to signal, not null
     */
    void onNext(@NonNull T value);

    /**
     * Signal a Throwable exception.
     * @param error the Throwable to signal, not null
     */
    void onError(@NonNull Throwable error);

    /**
     * Signal a completion.
     */
    void onComplete();
}

ObservableEmitter对接口Emitter进行扩展，增加了setDisposable、setCancellable等方法
下面看看create方法：

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

调用了RxJavaPlugins的onAssembly方法。又有一个新参数ObservableCreate<T>(source)，我们看看它是什么：

final class ObservableCreate<T> extends Observable<T> {

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

}

继承了Observable，是被观察对象，在构造函数中我们看到我们new ObservableOnSubscribe对象，被存在了ObservableCreate source引用里

onAssembly方法：

public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

一个Hook方法。onObservableAssembly是一个静态变量，没有设置默认为空，所以直接返回source对象。也就是说，Observable的create方法其实就是把ObservableOnSubscribe对象存储在ObservableCreate对象的source引用里，然后返回该ObservableCreate对象。
ObservableCreate是继承Observable的，所以创建了ObservableCreate对象，Observable也就创建完了。

2.2 订阅事件（被观察者）

订阅操作是observable.subscribe(new Observer<String>())。这里是被观察者订阅观察者，主要是因为链式调用方便，因为subscribe方法里的参数Observer才是观察者。我们也会在Observer里的各个被调方法里接收到事件相关的返回值。
subscribe订阅方法的源码：

  public final void subscribe(Observer<? super T> observer) {
        try {
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            RxJavaPlugins.onError(e);
        }
    }

实际上调用了subscribeActual(observer);，这个方法是Observable里的方法，而此时的Observable是一个ObservableCreate对象。ObservableCreate里面的subscribeActual如下：

protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

方法主要做了三件事：

1. 创建一个CreateEmitter对象parent;
2. 把parent传给source的subscribe方法，也就是ObservableOnSubscribe对象的subscribe方法：

@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
     e.onNext("a");
}

所以在这个方法里就能收到一个CreateEmmiter，通过CreateEmitter可以回调相应的方法。CreateEmitter是实现ObservableEmitter接口，内部onNext源码如下：

@Override
public void onNext(T t) {
    observer.onNext(t);
}

也就是说，当我们在ObservableOnSubscribe的subscribe方法里调用ObservableEmitter的onNext方法的时候，它里面会调用observer的onNext。于是通过这样的传递就能在observer的回调方法里收到。

总结无背压Rxjava（observable/observer）：

1、使用Observbable.create方法，产生一个ObservableCreate对象，对象里存着ObservableOnSubscribe对象source。

2、调用ObservableCreate.subscribe方法，实际调用的是subscribeActual方法，传入一个Observer对象。

3、subscribeActual方法中创建一个CreateEmmiter对象，调用source.subscribe方法，传入CreateEmmiter对象。

4、于是我们在ObservableOnSubscribe中就接收到了一个CreateEmmiter，CreateEmmiter是ObservableEmmiter的子类。我们可以在这里调用CreateEmmiter的方法进行事件回调。

5、调用CreateEmmiter方法，实际上会调用Observer的响应的方法。也就是CreateEmmiter把事件状态传递给观察者。