Rxjava源码分析

原创 于 2017-12-04 09:39:13 发布 · 334 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

   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方法

这样就起到了变换的作用
向龙宙
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值