RxJava2

来源：互联网发布：剑三喵哥捏脸数据编辑：程序博客网时间：2024/06/01 08:31

        Observable.just(1, 2)                .filter(integer -> integer > 1)                .subscribe(System.out::println);

filer 是把 just(1,2) 变成 just(2) 了吗？ No

public final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {    final Predicate<? super T> predicate;    public ObservableFilter(ObservableSource<T> source, Predicate<? super T> predicate) {        super(source);        this.predicate = predicate;    }    @Override    public void subscribeActual(Observer<? super T> s) {        source.subscribe(new FilterObserver<T>(s, predicate));    }    static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {        final Predicate<? super T> filter;        FilterObserver(Observer<? super T> actual, Predicate<? super T> filter) {            super(actual);            this.filter = filter;        }        @Override        public void onNext(T t) {            if (sourceMode == NONE) {                boolean b;                try {                    b = filter.test(t);                } catch (Throwable e) {                    fail(e);                    return;                }                if (b) {                    actual.onNext(t);                }            } else {                actual.onNext(null);            }        }        ...    }}

source 是上层(upstream) 下来的源

    @Override    public void subscribeActual(Observer<? super T> s) {        source.subscribe(new FilterObserver<T>(s, predicate));    }

subscribe 的实现被委托给上层的源，过滤的实现通过用

FilterObserver 包装的原有的额 Observer 实现。

onNext 行为被包装了一个判断，通过预期 filter.test

   Observable.just(1, 2)                .map(integer -> integer+"")                .subscribe(System.out::println);

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

和 filter 是一种设计，递归思想真的很重要。

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

mapper 是转换规则，是 Function 接口，等价于传递函数。

如果转换过程中抛出异常，

   protected final void fail(Throwable t) {        Exceptions.throwIfFatal(t);        s.dispose();        onError(t);    }

onError 会被掉用，因为 dispose 观测停止。

结合起来

        Observable.just(1, 2)                .filter(integer -> integer > 0)                .map(integer -> integer + "")                .subscribe(System.out::println);

实际执行

just(1.2).subscribe MapObserver(FilterObserver(sout))

两层包装类会改变 onNext ，类型，是否执行。

阅读全文

0 0