什么年代了,还异步编程,异步编程了不起啊,当然不,只是它让代码更帅气一点,在这个颜值至上的社会,这难道还不重要吗?
来看一个,如果只想在某个时间段内监听只接受一个值,我们该怎么处理, let's go!
@Test
fun observer(){
Observable.create<String> {
it.onNext("purple")
// 等待0.51秒,让第一个发送成功
Thread.sleep(520)
it.onNext("blue")
it.onNext("gray green")
it.onNext("green")
// 等待0.51秒,让最后一个发送成功
Thread.sleep(510)
}.debounce(500, TimeUnit.MILLISECONDS).subscribe {
println("emit = $it")
}
}
怎么说,有没有点含金量?
ReativeX架构
基本的函数式就由这几个组成,康康心里有搭配的笔数就好,关键理解操作符下对应类别的操作的处理
源码解析
Observable.create( )
- 创建Observable
public static <T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
Objects.requireNonNull(source, "source is null");
// 1-1:实例化Observable
return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
}
// 1-2:ObservableCreate,看到没有这比extends Observable<T>
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
...
}
- Observable中间处理
// 2-1:可以看到这笔一开始就是null的
static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
// 2-2:这里不做别的考虑,肯定f == null
if (f != null) return apply(f, source);
// 2-3:返回实例化好的Observable
return source;
}
subscribe( )
- 传入Observer/Consumer
1-1: 默认Consumer实例化
public final Disposable subscribe(@NonNull Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION);
}
1-2: 进行Subscribe
public final Disposable subscribe(@NonNull Consumer<? super T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) {
// 好家伙,这里构造响应回调
LambdaObserver<T> ls = new LambdaObserver<>(onNext, onError, onComplete, Functions.emptyConsumer());
// 传入回调
subscribe(ls);
return ls;
}
1-2-1:LambdaObserver构造
public final class LambdaObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable, LambdaConsumerIntrospection {
...
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;
}
}
public final void subscribe(@NonNull Observer<? super T> observer) {
...
observer = RxJavaPlugins.onSubscribe(this, observer);
// 1-3:这里要知道,我们使用的是ObservableCreate来构建
subscribeActual(observer);
...
}
- 不同的Observable,有不同的subscribeActual实现,这里看ObservableCreate
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<>(observer);
// 2-1:ObservableOnSubscribe/Observer ,监听消息传递
observer.onSubscribe(parent);
source.subscribe(parent);
...
}
}
onNext(消息传递)
- Observable发送消息
1-1: Emitter接口基本定义
public interface Emitter<@NonNull T> {
void onNext(@NonNull T value);
void onError(@NonNull Throwable error);
void onComplete();
}
1-2:ObservableCreate.CreateEmitter
public final class ObservableCreate<T> extends Observable<T> {
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(ExceptionHelper.createNullPointerException("onNext called with a null value."));
return;
}
1-3: 看到没有这里给observer发消息了
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {...}
@Override
public boolean tryOnError(Throwable t) {...}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
@Override
public void setDisposable(Disposable d) {...}
@Override
public void setCancellable(Cancellable c) {...}
@Override
public ObservableEmitter<T> serialize() {
return new SerializedEmitter<>(this);
}
@Override
public void dispose() {...}
@Override
public boolean isDisposed() {...}
@Override
public String toString() {...}
}
}
- Observer接收消息
public enum DisposableHelper implements Disposable {
public static boolean setOnce(AtomicReference<Disposable> field, Disposable d) {
Objects.requireNonNull(d, "d is null");
if (!field.compareAndSet(null, d)) {
d.dispose();
if (field.get() != DISPOSED) {
reportDisposableSet();
}
return false;
}
return true;
}
}
public final class LambdaObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable, LambdaConsumerIntrospection{
@Override
public void onSubscribe(Disposable d) {
2-1:这里判断Disposable是否多次设置,这里强行让其只能赋值一次
if (DisposableHelper.setOnce(this, d)) {
try {
onSubscribe.accept(this);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
d.dispose();
onError(ex);
}
}
}
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
2-2:看到没有这里给onNext回调传值
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().dispose();
onError(e);
}
}
}
@Override
public void onError(Throwable t) {...}
@Override
public void onComplete() {
if (!isDisposed()) {
lazySet(DisposableHelper.DISPOSED);
try {
onComplete.run();
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
}
}
}
@Override
public void dispose() {...}
@Override
public boolean isDisposed() {...}
@Override
public boolean hasCustomOnError() {...}
}
