我們繼續來學習RxJava的原始碼，今天主要會學習RxJava中的操作符變換原理。
  本文重點講解Observable，Flowable跟Observable非常的像，所以就不做講解。

1.概述

  就Observable而言，操作符變化主要涉及的兩個類：AbstractObservableWithUpstream和ObservableOperator。
  其中，我們可以看到的是，RxJava給我們的變換操作符,包括map,flatMap、buffer等操作符等繼承於AbstractObservableWithUpstream類。
  而ObservableOperator介面主要用於自定義操作符，然後配合lift操作符，美滋滋??。
  AbstractObservableWithUpstream和ObservableOperator都有一個共同的特點，那就是進行變換時，都會找一箇中間的Observer。Observable先將資料傳遞到中間的Observer的onNext方法,然後在onNext方法進行變換，變換之後，在傳遞給我們的Observer。這一點，我們必須瞭解。

2. AbstractObservableWithUpstream

  我們先來看看AbstractObservableWithUpstream這個類，看一下這個類為我們做了哪些事情。

abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
    protected final ObservableSource<T> source;
    AbstractObservableWithUpstream(ObservableSource<T> source) {
        this.source = source;
    }
    @Override
    public final ObservableSource<T> source() {
        return source;
    }
}

  首先，我們看到的是，AbstractObservableWithUpstream是包許可權，也就是RX官方也不希望我們來使用這個類。
  這個類表示的意思非常簡單，實現了HasUpstreamObservableSource介面，並且實現了source方法，返回了一個ObservableSource物件。
  我們感覺AbstractObservableWithUpstream根本沒做什麼事情，是的，我也這麼覺得??。
  為了更好理解操作變換原理，我們來簡單的看看map操作符。關於操作符的理解，本文只是簡單做一個理解，如果後續有需要的話，可以對某些操作符做單獨的分析。

(1).map操作符

  map操作符主要涉及到的是ObservableMap類，主要是在這個類對中間Observer進行了subscribe。我們來看看：

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Function<? super T, ? extends U> function;

    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
        super(source);
        this.function = function;
    }

    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

  我們看到，在subscribeActual方法裡面進行了subscribe操作，然後Observable的onNext等操作都會執行到MapObserver相應的操作當中來。
  我們知道，map操作主要是將一個資料從一種型別轉換為另一個種型別。而這種實現主要是在onNext方法裡面進行的，我們來看看MapObserver的onNext方法：

        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                actual.onNext(null);
                return;
            }

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            actual.onNext(v);
        }

  在onNext方法裡面，呼叫了Function的apply方法將一個資料從一個型別轉換為另一個型別，然後在呼叫我們的Observer的onNext方法將轉換之後的資料傳遞下去。這就是整個map轉換的過程。
  從這裡，可以應證前面的一點，那就是需要一箇中間Observer來實現。這種實現方法相當於是一個組合式的代理模式，代理物件是中間的Observer，真正做操作的是我們的Observer。

3. ObservableOperator

  我們來看看ObservableOperator類，看看我們怎麼通過ObservableOperator來自定義一個操作符。之前說過，ObservableOperator需要跟lift操作符來實現。所以，我們先來看看lift操作符:

    public final <R> Observable<R> lift(ObservableOperator<? extends R, ? super T> lifter) {
        ObjectHelper.requireNonNull(lifter, "onLift is null");
        return RxJavaPlugins.onAssembly(new ObservableLift<R, T>(this, lifter));
    }

  好吧，我們來看看ObservableLift：

public final class ObservableLift<R, T> extends AbstractObservableWithUpstream<T, R> {
    final ObservableOperator<? extends R, ? super T> operator;

    public ObservableLift(ObservableSource<T> source, ObservableOperator<? extends R, ? super T> operator) {
        super(source);
        this.operator = operator;
    }

    @Override
    public void subscribeActual(Observer<? super R> s) {
        Observer<? super T> observer;
        try {
            observer = ObjectHelper.requireNonNull(operator.apply(s), "Operator " + operator + " returned a null Observer");
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }

        source.subscribe(observer);
    }
}

  在這個類裡面，主要是在subscribeActual方法裡面做了一次apply的操作，通過這個操作，我們獲取了一個新的Observer，這個新的Observer就是我們的Observer，然後再subscribe。這個也是非常的簡單。現在我們來通過一個小小的案例來實現一個map操作符。

(1).實現Map操作符

  我們先定義了一個ObserverMap用來將一個U型別轉換為T型別

public class ObserverMap<T, U> implements ObservableOperator<T, U> {

  private Function<U, T> mFunction;

  public ObserverMap(Function<U, T> function) {
    this.mFunction = function;
  }

  @Override
  public Observer<? super U> apply(final Observer<? super T> observer) throws Exception {
    return new Observer<U>() {
      @Override
      public void onSubscribe(Disposable d) {
        observer.onSubscribe(d);
      }

      @Override
      public void onNext(U u) {
        observer.onNext(mFunction.apply(u));
      }

      @Override
      public void onError(Throwable e) {
        observer.onError(e);
      }

      @Override
      public void onComplete() {
        observer.onComplete();
      }
    };
  }
}

  整個類也是非常的簡單，只在onNext方法中做了一次型別轉換。
  然後，我們看一下，是怎麼使用的：

    Observable.create(new ObservableOnSubscribe<Integer>() {
      @Override
      public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
      }
    }).lift(new ObserverMap<>(new Function<Integer, String>() {
      @Override
      public String apply(Integer input) {
        return "input = " + String.valueOf(input);
      }
    })).subscribe(new Consumer<String>() {
      @Override
      public void accept(String s) throws Exception {
        Log.i("pby123", s);
      }
    });

4.總結

  總的來說，這篇文章是非常的簡單的，這裡的講解主要對後面打一個基礎，後續有可能會對一些操作符進行分析，同時講解一下這個，相信大家以後看到相關的程式碼不會懵逼。