RxJava2

最新推荐文章于 2023-02-16 10:04:31 发布

原创最新推荐文章于 2023-02-16 10:04:31 发布 · 559 阅读

0 ·

CC 4.0 BY-SA版权

RxJava 专栏收录该内容

2 篇文章

订阅专栏

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

1
2

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 ，类型，是否执行。