EventBus3.0阅读笔记

简述

很多时候有的业务隔离的很严重，但是有需要在一定的时机上互相通知，为了解决这个场景有一种比较合适的方案，就是事件总线机制。EventBus就是该机制的一种实现，基于观察者模式，简单说就是有一个总线控制，然后观察者挂载到总线上，然后有消息发送出来之后，总线根据挂载情况进行分发。
以下代码基于EventBus3.0

参数和构造

先看一下EventBus基础的参数和构造：

    //DCL单例模式
    static volatile EventBus defaultInstance;

    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
    //原始事件和该事件可以进行回调的其他事件列表的集合
    //一般来说就是结合eventInheritance
    //然后会记录自己的所有父类和所实现的所有接口(包括每一个父类所实现的接口)等
    private static final Map, List>> eventTypesCache = new HashMap<>();
    //回调的方法对应的参数(事件)和对应的订阅者单元(订阅的类和具体的某一个方法)所构成的集合
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    //订阅者(类)和其所对应的所有事件的列表
    private final Map>> typesBySubscriber;
    //黏性事件的对象所对应的类和对象所构成的集合
    private final Map, Object> stickyEvents;
    //每一个线程都有自己对应的发送状态等参数
    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };
    //用于在主线程进行事件的回调处理方法
    private final HandlerPoster mainThreadPoster;
    //用于在EventBus的线程池即executorService中的子线程进行事件的回调处理
    //内部的实现会在执行队列非空的情况下使用单一的线程一直执行，并且规定了最大等待(空闲)时间
    //只有在超过该空闲时间之后，再进行任务，才有可能使用其他线程
    //不过默认使用的是cacheExecutor，这意味着至少还有60s的空闲时间，在此期间也是能够继续复用线程的
    private final BackgroundPoster backgroundPoster;
    //用于在EventBus的线程池即executorService中的子线程进行事件的回调处理
    //区别于BackgroundPoster来说这个post是单纯通过线程池调度
    private final AsyncPoster asyncPoster;
    //用于查找所有观察者用于回调处理事件的方法
    private final SubscriberMethodFinder subscriberMethodFinder;
    //线程池，用于处理在子线程中进行的回调
    private final ExecutorService executorService;

    //当某一个事件在发送的时候有观察者处理，但是在进行函数回调的时候出现InvocationTargetException异常
    //此时是否抛出异常，如果抛出异常，那么sendSubscriberExceptionEvent和logSubscriberExceptions直接就无效了
    private final boolean throwSubscriberException;
    //当某一个事件在发送的时候有观察者处理，但是在进行函数回调的时候出现InvocationTargetException异常
    //此时是否要打印日志
    private final boolean logSubscriberExceptions;
    private final boolean logNoSubscriberMessages;
    //当某一个事件在发送的时候有观察者处理，但是在进行函数回调的时候出现InvocationTargetException异常
    //是否需要额外的发送一个预先定义的SubscriberExceptionEvent事件
    private final boolean sendSubscriberExceptionEvent;
    //当某一个事件在发送的时候没有观察者处理
    //是否需要额外的发送一个预先定义的NoSubscriberEvent事件，这个事件会记录的之前那个没有被处理的事件
    private final boolean sendNoSubscriberEvent;
    //是否处理子类事件，如果为true的时候，假设有一个事件A发送出去
    //而某一个观察者中的处理事件可能为A的父类，那么此时也会进行事件回调
    private final boolean eventInheritance;
    //Builder中注册的索引数量
    private final int indexCount;

    /** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

EventBus为单例模式，也就是一个总线控制台。可以看到实际上观察者都是在内存中的。

观察者的注册

    /**
     * 注册一个观察者用于接收指定的一些事件，实际上就是查找回调方法，然后记录一堆数据
     * 当观察者不再关心这些事件的时候，要通过unregister注销，从而使得观察者不再接收那些事件的回调
     * 观察者必须要有回调方法，且该回调方法必须通过@Subscribe进行注解
     * 该注解还可以指定线程和优先级
     */
    public void register(Object subscriber) {
        //获得观察者的类，比方说在AFragment中注册，那么这里就会获得AFragment这个类
        Class subscriberClass = subscriber.getClass();
        //通过观察者类查找里面定义的所有回调方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {//这个只是对象锁，这就意味着不同的EventBus实例，事件的回调不会互相上锁
            //为了防止处理过程中列表变化，这里必须上锁
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

    /**
     * 将当前观察者和对应的方法记录在缓存当中，相当于标记注册
     * 不允许重复添加！所以说重复添加之前必须进行反注册或者清除缓存
     * 如果当前观察者进行回调的方法处理黏性事件，那么需要尝试进行黏性事件回调
     * @param subscriber 当前的观察者
     * @param subscriberMethod 当前的观察者所定义的某一个具体的事件回调方法
     */
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获得当前方法对应的事件，实际上就是观察者所观察的某一个事件
        Class eventType = subscriberMethod.eventType;
        //通过观察者和该方法定义一个个新的观察单元
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //从缓存中通过当前事件获得观察单元
        //同一个事件当然可以有不同的观察者
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            //当前事件没有观察单元处理，新建
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            //其实就是不允许同一个类重复注册，要重新注册，那么之前必须反注册
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }
        //将当前观察元素添加到缓存中
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            //可以看到，在注册的时候优先级大的会在同一个事件的观察元素队列中靠前
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }
        //从缓存中通过观察者获得其所观察的所有事件类型
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {//之前没有缓存，新建
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);//将当前事件放入缓存，建立了观察者和其所观察的某一个事件的缓存

        if (subscriberMethod.sticky) {//当前观察者的回调方法是处理黏性事件的
            if (eventInheritance) {
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, Object> entry : entries) {//遍历黏性事件缓存
                    Class candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        //如果当前观察者的回调方法处理的事件类型为缓存中某一个黏性事件的父类
                        //举例说明当前方法处理的黏性事件为A
                        //之前已经有黏性事件B发送过了，而且满足B extends A
                        //那么当前B事件也会进行回调处理
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                //从缓存中通过当前事件来获取黏性事件，如果在这之前已经有黏性事件发送，那么缓存中必定有值
                Object stickyEvent = stickyEvents.get(eventType);
                //如果缓存中有值，即null != stickyEvent，说明之前该黏性事件已经发送过了，尝试进行回调
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

    /**
     * 检查当前黏性事件是否为空
     * 非空则进行事件回调处理
     * @param newSubscription 订阅元素（当前的观察者和其处理当前黏性事件的方法）
     * @param stickyEvent 当前可能需要进行回调的黏性事件
     */
    private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
        }
    }

实际上就是记录了当前观察者和观察者想要观察的事件、回调方法。
这个从上面的参数中也可以看到：
1.观察者和该观察者所关心的事件列表所构成的映射，这个一般用于判断某一个观察者是否注册。
2.事件和可以处理该事件的观察者、回调方法所构成的映射，这个用于在发送事件的时候快速查找对应的回调。其中该队列有按照优先级排序，后续在回调的时候可以看到是正序遍历的，所以说优先级高的会先回调。
其中稍微注意一下黏性事件，简单的理解就是黏性事件一旦发送，哪怕观察者在后面注册，也会收到该事件。

事件发送

    /**
     * 发送一个黏性事件
     * 这个事件会保留在内存当中，然后如果发送之后还有黏性事件的观察者注册了
     * 此时该事件也可能会进行回调处理
     */
    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);//黏性事件会保留在内存当中
        }
        //当前先发送事件给之前注册了当前事件的观察者
        post(event);
    }

    /**
     * 发送一个事件到事件总线上，并且尝试进行对应的回调
     * @param event 当前需要发送的事件
     * */
    public void post(Object event) {
        //通过当前调用的线程获得对应的PostingThreadState
        PostingThreadState postingState = currentPostingThreadState.get();
        //获取当前线程的事件队列
        List