【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对象，并通过source的subscribe方法将其传递给我们自定义的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类实现了Observer和Disposable接口，它用于处理订阅时的操作，并在收到数据项时使用传入的predicate对数据项进行过滤。如果数据项满足predicate的条件，就将其发射给观察者。

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