Rxjava源码分析

   Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override

            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                Log.i("xiang","发射.1");

                emitter.onNext(1);

                Log.i("xiang","发射.2");

                emitter.onNext(2);

                Log.i("xiang","发射.3");

                emitter.onNext(3);

            }

        }).map(new Function<Integer, String>() {

            @Override

            public String apply(Integer integer) throws Exception {

                Log.i("xiang","变换...");

                return "This is result " + integer;

            }

        }).subscribe(new Consumer<String>() {

            @Override

            public void accept(String s) throws Exception {

                Log.i("xiang","subscribe...");

            }

        });

 

以上为一个基本的Rxjava建立订阅的方式

执行结果为：

* 11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 发射.1

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 变换...

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: subscribe...

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 发射.2

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 变换...

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: subscribe...

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 发射.3

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: 变换...

11-28 16:52:43.173 9547-9547/com.xlz.rxjavatest I/xiang: subscribe...

* */

观察运行结果可以知道，emitter执行一次onNext,则整个流程执行一遍，  就是发射--->变换---->accept

从subscribe方法看起

@SchedulerSupport(SchedulerSupport.NONE)

public final Disposable subscribe(Consumer<? super T> onNext) {

return subscribe(onNext, Functions.ERROR_CONSUMER, Functions.EMPTY_ACTION, Functions.emptyConsumer());

}

点进去

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,

Action onComplete, Consumer<? super Disposable> onSubscribe) {

ObjectHelper.requireNonNull(onNext, "onNext is null");

ObjectHelper.requireNonNull(onError, "onError is null");

ObjectHelper.requireNonNull(onComplete, "onComplete is null");

ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

subscribe(ls);

return ls;

}

这里可以看到，将onNext,onError,onComplete,onSubscribe封装成一个LamdaObserver对象

点进去

public final class LambdaObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

private static final long serialVersionUID = -7251123623727029452L;

final Consumer<? super T> onNext;

final Consumer<? super Throwable> onError;

final Action onComplete;

final Consumer<? super Disposable> onSubscribe;

public LambdaObserver(Consumer<? super T> onNext, Consumer<? super Throwable> onError,

Action onComplete,

Consumer<? super Disposable> onSubscribe) {

super();

this.onNext = onNext;

this.onError = onError;

this.onComplete = onComplete;

this.onSubscribe = onSubscribe;

}

@Override

public void onSubscribe(Disposable s) {

if (DisposableHelper.setOnce(this, s)) {

try {

onSubscribe.accept(this);

} catch (Throwable ex) {

Exceptions.throwIfFatal(ex);

onError(ex);

}

}

}

@Override

public void onNext(T t) {

if (!isDisposed()) {

try {

onNext.accept(t);

} catch (Throwable e) {

Exceptions.throwIfFatal(e);

onError(e);

}

}

}

@Override

public void onError(Throwable t) {

if (!isDisposed()) {

dispose();

try {

onError.accept(t);

} catch (Throwable e) {

Exceptions.throwIfFatal(e);

RxJavaPlugins.onError(new CompositeException(t, e));

}

}

}

@Override

public void onComplete() {

if (!isDisposed()) {

dispose();

try {

onComplete.run();

} catch (Throwable e) {

Exceptions.throwIfFatal(e);

RxJavaPlugins.onError(e);

}

}

}

@Override

public void dispose() {

DisposableHelper.dispose(this);

}

@Override

public boolean isDisposed() {

return get() == DisposableHelper.DISPOSED;

}

}

这里没什么好说的， 就是把几个Consumer对象组合在一起了，在调用onSubsribe、onNext 、onError、onComplete的时候调用响应的Cosumer的方法

继续看suscribe(ls)方法

点进去

@SchedulerSupport(SchedulerSupport.NONE)

    @Override

    public final void subscribe(Observer<? super T> observer) {

        ObjectHelper.requireNonNull(observer, "observer is null");

        try {

            observer = RxJavaPlugins.onSubscribe(this, observer);

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

            subscribeActual(observer);

        } catch (NullPointerException e) { // NOPMD

            throw e;

        } catch (Throwable e) {

            Exceptions.throwIfFatal(e);

            // can't call onError because no way to know if a Disposable has been set or not

            // can't call onSubscribe because the call might have set a Subscription already

            RxJavaPlugins.onError(e);

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

            npe.initCause(e);

            throw npe;

        }

    }

可以看到，这里是调用了subscribeActual(observer)

subscribeActual是Observable的抽象方法

从Debug得知，这里实际调用的是子类对象ObservableCreate的subscribeActual方法

如下：

@Override

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);

}

}

可以看到，这里用了CreateEmitter,那么看一下CreateEmitter

static final class CreateEmitter<T>

extends AtomicReference<Disposable>

implements ObservableEmitter<T>, Disposable {

private static final long serialVersionUID = -3434801548987643227L;

final Observer<? super T> observer;

CreateEmitter(Observer<? super T> observer) {

this.observer = observer;

}

@Override

public void onNext(T t) {

if (t == null) {

onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));

return;

}

if (!isDisposed()) {

observer.onNext(t);

}

}

@Override

public void onError(Throwable t) {

if (t == null) {

t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");

}

if (!isDisposed()) {

try {

observer.onError(t);

} finally {

dispose();

}

} else {

RxJavaPlugins.onError(t);

}

}

@Override

public void onComplete() {

if (!isDisposed()) {

try {

observer.onComplete();

} finally {

dispose();

}

}

}

@Override

public void setDisposable(Disposable d) {

DisposableHelper.set(this, d);

}

@Override

public void setCancellable(Cancellable c) {

setDisposable(new CancellableDisposable(c));

}

@Override

public ObservableEmitter<T> serialize() {

return new SerializedEmitter<T>(this);

}

@Override

public void dispose() {

DisposableHelper.dispose(this);

}

@Override

public boolean isDisposed() {

return DisposableHelper.isDisposed(get());

}

}

CreateEmitter是ObservableCreate的静态内部类

里面有Oberser的一个成员，在构造方法里将Observer对象赋给个这个成员

，那么在调用CreateEmitter的onNext,onComplete,实际就是在调用

Observer的onNext,onComplete方法。这就是观察者模式。

这就可以解释，emitter调用onNext方法后，Comsuer的accept方法也会执行了。

下面继续看observer.onSubscribe(parent);

这个observer实际就是LamdaObserver对象

那么实际这里是调用了LamdaObserver的onSubscribe方法

如下：

@Override

public void onSubscribe(Disposable s) {

if (DisposableHelper.setOnce(this, s)) {

try {

onSubscribe.accept(this);

} catch (Throwable ex) {

Exceptions.throwIfFatal(ex);

onError(ex);

}

}

}

首先看DisposableHelper.setOnce(this,s)

public static boolean setOnce(AtomicReference<Disposable> field, Disposable d) {

ObjectHelper.requireNonNull(d, "d is null");

if (!field.compareAndSet(null, d)) {

d.dispose();

if (field.get() != DISPOSED) {

reportDisposableSet();

}

return false;

}

return true;

}

这里用到了compareAndSet（expect,update）方法，看注释

Atomically sets the value to the given updated value

* if the current value {@code ==} the expected value.

如果当前value和expect相等，则设置为update的新值

成功返回true,失败返回false

那么对于setOnce方法，如果field为null，则if里面不会执行，setOnce直接返回true

否则返回false

//没分析完，关于Diposeable

继续看 subscribActual

里的source.subscribe(parent);

这里的source是ObservableOnSubscribe 对象

可以看到建立订阅后，就会调用ObservableOnSubscribe的subscribe(ObservableEmitter<Integer> emitter)方法

即开始发射事件

下面分析map

@SchedulerSupport(SchedulerSupport.NONE)

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {

ObjectHelper.requireNonNull(mapper, "mapper is null");

return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));

}

这里看到onAssembly方法传入了一个ObservableMap对象

看ObservableMap 构造方法

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {

super(source);

this.function = function;

}

可以看到，把function对象赋给了ObservableMap的成员变量function

继续看onAssembly方法

public static <T> Observable<T> onAssembly(Observable<T> source) {

Function<Observable, Observable> f = onObservableAssembly;

if (f != null) {

return apply(f, source);

}

return source;

}

通过调试得知，onObservableAssembly 是null,那么这里直接返回source

即返回ObservableMap对象

那么原来的Observable对象通过map方法后变成了ObservableMap对象

继续看ObservableMap全部源码

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));

    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {

        final Function<? super T, ? extends U> mapper;

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {

            super(actual);

            this.mapper = mapper;

        }

        @Override

        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);

        }

        @Override

        public int requestFusion(int mode) {

            return transitiveBoundaryFusion(mode);

        }

        @Override

        public U poll() throws Exception {

            T t = qs.poll();

            return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;

        }

    }

}

那么在执行Observable的subscribe时，实际是在执行ObservableMap的subscribeActual方法

在emitter执行onNext方法就是执行了MapObserver的onNext方法

这样就起到了变换的作用