【Rxjava详解】(六)操作符执行原理

解析一些常见操作符的执行原理,它们都会交给Observablexxx去执行,然后在进行自己的处理。

map()

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

它接受一个Function参数,该参数定义了将原始Observable发射的数据项转换为另一种类型的数据项的逻辑。下面是关于源码的注释:

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
    // 检查传入的mapper参数是否为空,如果为空则抛出异常
    ObjectHelper.requireNonNull(mapper, "mapper is null");
    
    // 创建一个新的Observable,使用this(原始Observable)和传入的mapper参数
    // ObservableMap是一个自定义操作符,它实现了ObservableTransformer接口
    // 它负责将原始Observable发射的数据项转换为另一种类型的数据项
    return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}

下面是ObservableMap类的部分源代码:

public final class ObservableMap<T, R> extends AbstractObservableWithUpstream<T, R> {
    final Function<? super T, ? extends R> mapper;
    
    // 构造方法接受原始Observable和mapper参数
    public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends R> mapper) {
        super(source);
        this.mapper = mapper;
    }
    
    // 在订阅时,创建一个新的Observer,并订阅原始Observable
    @Override
    public void subscribeActual(Observer<? super R> observer) {
        source.subscribe(new MapObserver<T, R>(observer, mapper));
    }
    
    // 自定义的MapObserver类,实现了Observer接口
    static final class MapObserver<T, R> implements Observer<T> {
        final Observer<? super R> observer;
        final Function<? super T, ? extends R> mapper;
        
        // 构造方法接受observer和mapper参数
        MapObserver(Observer<? super R> observer, Function<? super T, ? extends R> mapper) {
            this.observer = observer;
            this.mapper = mapper;
        }
        
        // 当原始Observable发射数据项时,通过mapper将数据项转换为新的类型
        // 然后将转换后的数据项发射给observer
        @Override
        public void onNext(T t) {
            R result;
            try {
                result = mapper.apply(t);
            } catch (Throwable ex) {
                onError(ex);
                return;
            }
            observer.onNext(result);
        }
        
        // 其他方法的实现省略...
    }
}

ObservableMap类中,我们可以看到它实现了Observer接口,并在onNext方法中使用传入的mapper将原始Observable发射的数据项转换为新的类型,然后将转换后的数据项发射给订阅者。

create()

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    // 检查参数的合法性,如果传入的 source 为 null,则抛出异常
    Objects.requireNonNull(source, "source is null");
    // 创建一个新的 Observable 对象,传入 source 参数
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

下面是ObservableCreate类的部分源代码:

public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;
    
    // 构造方法接受 source 参数
    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }
    
    // 在订阅时,创建一个新的 Observer,并调用 source 的 subscribe 方法
    @Override
    protected void subscribeActual(Observer observer) {
        CreateEmitter parent = new CreateEmitter(observer);
        observer.onSubscribe(parent);
        try {
            // 调用 source 的 subscribe 方法,传入 parent(CreateEmitter)
            // 这里会执行用户自定义的逻辑,比如发射数据项、发射错误、发射完成等操作
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
    
    // 自定义的 CreateEmitter 类,实现了 ObservableEmitter 接口
    static final class CreateEmitter implements ObservableEmitter, Disposable {
        final Observer observer;
        volatile boolean disposed;
        
        CreateEmitter(Observer observer) {
            this.observer = observer;
        }
        
        // 实现了 ObservableEmitter 接口的方法,用于发射数据项给观察者
        @Override
        public void onNext(T value) {
            if (!isDisposed()) {
                if (value != null) {
                    observer.onNext(value);
                } else {
                    onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                }
            }
        }
        
        // 其他方法的实现省略...
    }
}

ObservableCreate类中,我们可以看到它继承自Observable类,并实现了subscribeActual方法。在subscribeActual方法中,它创建了一个新的CreateEmitter对象,并通过sourcesubscribe方法将其传递给我们自定义的ObservableOnSubscribe对象。

CreateEmitter类实现了ObservableEmitter接口,它提供了一系列方法用于发射数据项给观察者

just()

public static <T> Observable<T> just(T item) {
    // 将单个数据项封装成一个数组
    ObjectHelper.requireNonNull(item, "The item is null");
    // 创建一个新的 Observable 对象,传入单个数据项的数组
    return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}

下面是ObservableJust类的部分源代码:

public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
    final T value;
    
    // 构造方法接受 value 参数
    public ObservableJust(T value) {
        this.value = value;
    }
    
    // 在订阅时,直接将 value 发射给观察者
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        ScalarDisposable<T> sd = new ScalarDisposable<T>(observer, value);
        observer.onSubscribe(sd);
        sd.run();
    }
    
    // 实现 ScalarCallable 接口的方法,用于返回单个数据项
    @Override
    public T call() {
        return value;
    }
    
    // 自定义的 ScalarDisposable 类,实现了 Disposable 接口
    static final class ScalarDisposable<T> implements Disposable {
        final Observer<? super T> observer;
        final T value;
        boolean disposed;
        
        ScalarDisposable(Observer<? super T> observer, T value) {
            this.observer = observer;
            this.value = value;
        }
        
        // 执行发射数据项给观察者的操作
        void run() {
            if (disposed) {
                return;
            }
            try {
                // 将 value 发射给观察者
                observer.onNext(value);
                if (!disposed) {
                    observer.onComplete();
                }
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (!disposed) {
                    observer.onError(ex);
                } else {
                    RxJavaPlugins.onError(ex);
                }
            }
        }
        
        // 其他方法的实现省略...
    }
}

ObservableJust类中,我们可以看到它继承自Observable类,并实现了subscribeActual方法。在subscribeActual方法中,它创建了一个新的ScalarDisposable对象,并将value直接发射给观察者。ScalarDisposable类实现了Disposable接口,它用于控制是否已经取消订阅,并在执行run方法时将value发射给观察者。

filter()

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> observer) {
        source.subscribe(new FilterObserver<T>(observer, predicate));
    }
    
    // 自定义的 FilterObserver 类,实现了 Observer 接口
    static final class FilterObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final Predicate<? super T> predicate;
        Disposable upstream;
        
        FilterObserver(Observer<? super T> downstream, Predicate<? super T> predicate) {
            this.downstream = downstream;
            this.predicate = predicate;
        }
        
        @Override
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
                downstream.onSubscribe(this);
            }
        }
        
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            
            boolean passed;
            try {
                // 使用传入的 predicate 对数据项进行过滤
                passed = predicate.test(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
                return;
            }
            
            if (passed) {
                downstream.onNext(t);
            }
        }
        
        // 其他方法的实现省略...
    }
}

ObservableFilter类中,我们可以看到它继承自AbstractObservableWithUpstream类,并实现了subscribeActual方法。在subscribeActual方法中,它创建了一个新的FilterObserver对象,并将源Observable对象和传入的predicate一起传递给FilterObserver

FilterObserver类实现了ObserverDisposable接口,它用于处理订阅时的操作,并在收到数据项时使用传入的predicate对数据项进行过滤。如果数据项满足predicate的条件,就将其发射给观察者。

filter操作符主要通过在onNext方法中使用传入的predicate对数据项进行过滤,并将符合条件的数据项发射给观察者。

你可能感兴趣的:(Rxjava,rxjava,android,java,观察者模式)