refer to:
First make a simplest RXJAVA:

/**
   * Observer
 */
public interface MyObserver<T> {

    void onSubscribe();
    void onNext(T t);
    void onError(Throwable e);
    void onComplete();
}

// Real observer
public interface MyObservableOnSubscrible<T> {

         Void Setobserver (Myobserver <T> OBServer); // Set downstream
}

/**
   * Is observed
 */
public class MyObservable<T> {

         // upstream object
    private MyObservableOnSubscrible<T> source;

         // Structure method for receiving upstream objects
    public MyObservable(MyObservableOnSubscrible<T> source) {
        this.source = source;
    }

         // Static method creates a real observer
    public static <T> MyObservable create(MyObservableOnSubscrible<T> source) {
        return new MyObservable(source);
    }

         / / Receive a downstream object here,
    public void setObserver(MyObserver<T> observer) {
        source.setObserver(observer);
         } // Set downstream
}

The three classes above are the most basic RXJAVA class, below is a simple use.

        MyObservable.create(new MyObservableOnSubscrible<Integer>() {
            @Override
            public void setObserver(MyObserver<Integer> observer) {
                Log.i (TAG, "Upstream Data: 10");
                observer.onNext(10);
            }
        }).setObserver(new MyObserver<Integer>() {
            @Override
            public void onSubscribe() {
                Log.i(TAG, "onSubscribe");
            }

            @Override
            public void onNext(Integer o) {
                                 Log.i (tag, "downstream received data:" + O);
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError");
            }

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete");
            }
        });

Output result:

COM.Example.test send data: 10
 COM.EXAMPLE.TEST downstream receives data: 10

Is it very similar to the chain of RxJava, but the variable name is a bit ugly, people are the subscribe method name, I am the SETOBSERVER method name, but it does not affect the use. We will change it in the later period, now in this way in order to better understand.
Analysis, finding the decorator mode here, Myobserver is an observer, MyobservableOnSubscribe is an actual observer, and MyObservable is a decorative class, which holds a MyobServableOnSubscribe object.

Custom MAP operator
It is obvious that the MAP operator is between the upstream and downstream, that is, their middle. In fact, this is also a thing that the decorator model is to do, that is, enhanced objects.