RxBus的小试牛刀

前言

RxBus并不是框架，而是一种类似观察者的模式。类似效果的还有EventBus和otto，
但是如果项目中使用了Rx响应式编程，那么用RxBus这种事件通信可以加深对响应式编程的熟练，以及不需要再引用任何库，它就是一个简单的类：

public class RxBus {
    private static RxBus sRxBus;
    private final Subject<Object, Object> mBus;

    // 注释1：PublishSubject 
    private RxBus() {
        mBus = new SerializedSubject<>(PublishSubject.create());
    }                //注释2

    // 单例
    public static RxBus getInstance() {
        if (sRxBus == null) {
            synchronized (RxBus.class) {
                if (sRxBus == null) {
                    sRxBus = new RxBus();
                }
            }
        }
        return sRxBus;
    }

    // 提供了一个新的事件
    public void post(Object o) {
        mBus.onNext(o);
    }

    // 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
    public <T> Observable<T> toObservable(Class<T> eventType) {
        return mBus.ofType(eventType);
    }
}

看一下注释1：

PublishSubject 分析

查看源码，有PublishSubject的示例：

    PublishSubject<Object> subject = PublishSubject.create();
//observer1 will receive all onNext and onCompleted events
    subject.subscribe(observer1);
    subject.onNext("one");
    subject.onNext("two");
//observer2 will only receive "three" and onCompleted
    subject.subscribe(observer2);
    subject.onNext("three");
    subject.onCompleted();

PublishSubject和 通常用的 Observable.subscribe(observer)或者Observable.subscribe(subscriber)不一样，Observable.subscribe会触发事件，
而PublishSubject.subscribe不会马上触发事件，而是onNext的时候才会触发。
所以订阅的subscriber或者observer 只能收到 它后面的onNext的事件。

看一下注释2：

SerializedSubject 分析

查看源码，有SerializedSubject 有这么一段注释：
Wraps a {@link Subject} so that it is safe to call its various {@code on} methods from different threads. When you use an ordinary {@link Subject} as a {@link Subscriber}, you must take care not to call its {@link Subscriber#onNext} method (or its other {@code on} methods) from multiple threads, as this could lead to non-serialized calls, which violates the Observable contract and creates an ambiguity in the resulting Subject.
意思就是说 你用普通的Subject 发射onNext的时候要注意不能在不同的线程发射，会引发线程安全的。

通常我们用 mySafeSubject = new SerializedSubject( myUnsafeSubject ); 将普通的Subject包裹进SerializedSubject 可以解决线程安全的问题。

继续看SerializedSubject 的源码，看一下它是怎么解决线程安全的问题。

public class SerializedSubject<T, R> extends Subject<T, R> {
    private final SerializedObserver<T> observer;
    private final Subject<T, R> actual;

    public SerializedSubject(final Subject<T, R> actual) {
        super(new OnSubscribe<R>() {

            @Override
            public void call(Subscriber<? super R> child) {
                actual.unsafeSubscribe(child);
            }

        });
        this.actual = actual;
        this.observer = new SerializedObserver<T>(actual);
    }

    @Override
    public void onCompleted() {
        observer.onCompleted();
    }

    @Override
    public void onError(Throwable e) {
        observer.onError(e);
    }
//原来SerializedSubject把onCompleted、onError、onNext都交给了SerializedObserver去处理。
    @Override
    public void onNext(T t) {
        observer.onNext(t);
    }

    @Override
    public boolean hasObservers() {
        return actual.hasObservers();
    }
}

SerializedSubject把onNext交给SerializedObserver去处理了，接着看看SerializedObserver的源码。

SerializedObserver 分析

还是看看源码的注释：
When multiple threads are emitting and/or notifying they will be serialized by:
Allowing only one thread at a time to emit
Adding notifications to a queue if another thread is already emitting
Not holding any locks or blocking any threads while emitting
有道词典翻译加个人理解：只允许onNext在同一时间只能在一个线程发射，
如果已经存在一个线程发射onNext，那么另一个发射onNext将添加到队列中，
在发射onNext过程中，不会持有任何锁和阻塞线程。

贴出SerializedObserver.onNext代码

    @Override
    public void onNext(T t) {
        if (terminated) {
            return;
        }
        synchronized (this) {
            if (terminated) {
                return;
            }
            //emitting为true，说明有线程已经正在发射onNext中
            if (emitting) {
                FastList list = queue;
                if (list == null) {
                    list = new FastList();
                    queue = list;
                }
                //把现在准备要发射的事件加到队列中，然后直接返回
                list.add(nl.next(t));
                return;
            }
            emitting = true;
        }
        try {
            //没有线程在发射onNext就直接 onNext 
            actual.onNext(t);
        } catch (Throwable e) {
            terminated = true;
            Exceptions.throwOrReport(e, actual, t);
            return;
        }
        for (;;) {
            for (int i = 0; i < MAX_DRAIN_ITERATION; i++) {
                FastList list;
                synchronized (this) {
                    list = queue;
                    //如果 队列 是空的，直接返回，发射ing 也置为false
                    if (list == null) {
                        emitting = false;
                        return;
                    }
                    queue = null;
                }
                for (Object o : list.array) {
                    if (o == null) {
                        break;
                    }
                    try {
                        //下面分析
                        //事件为 COMPLETED或者ERROR ，才终止
                        if (nl.accept(actual, o)) { 
                            terminated = true;
                            return;
                        }
                    } catch (Throwable e) {
                        terminated = true;
                        Exceptions.throwIfFatal(e);
                        actual.onError(OnErrorThrowable.addValueAsLastCause(e, t));
                        return;
                    }
                }
            }
        }
    }

上面看到了nl.accept(actual, o)，跟进去。 看到只有事件为 COMPLETED或者ERROR，才返回true，如果为ON_NEXT，依旧 死循环 for (;;)

public boolean accept(Observer<? super T> o, Object n) {
        if (n == ON_COMPLETED_SENTINEL) {
            o.onCompleted();
            return true;
        } else if (n == ON_NEXT_NULL_SENTINEL) {
            o.onNext(null);
            return false;
        } else if (n != null) {
            if (n.getClass() == OnErrorSentinel.class) {
                o.onError(((OnErrorSentinel) n).e);
                return true;
            }
            o.onNext((T) n);
            return false;
        } else {
            throw new IllegalArgumentException("The lite notification can not be null");
        }
    }

回到RxBus，发射事件

    public void post(Object o) {
        //bus就是PublishSubject，所以随时发射onNext都可以
        mBus.onNext(o);
    }

回到RxBus，订阅事件

    public <T> Observable<T> toObservable(Class<T> eventType) {
        return mBus.ofType(eventType);
    }

ofType = filter+cast

public final <R> Observable<R> ofType(final Class<R> klass) {
        return filter(InternalObservableUtils.isInstanceOf(klass)).cast(klass);
    }

filter 根据传进来的类过滤，post的时候只发射给对应的订阅者
cast 类型转换

结束

本文是分析源码以及查看资料，然后写的，有哪些地方不对的欢迎指出。
哈哈O(∩_∩)O哈哈~。