EventBus3.0源码分析

开头先扯淡：
之前分析了一篇viewmodel的源码，主要还是简单，里面的原理自己也看懂了，所以打算开始继续分析android主流框架源码，从简单的开始到难的，争取全部分析一遍立个flag，【捂脸】，这篇不打算很细致的把eventbus的每一个细节实现都讲出来，但是会把大致的实现思路通俗介绍一下。

这里才是正文：
在项目中我想大部分的人都会使用过事件处理框架EventBus吧，他可以方便我们在Android中应用组件进行复杂的通讯，可谓利器，我对他的了解程度就是他是基于观察者模式，事件发布之后可以到处订阅，但是它内部是如何做到的我还没有仔细研究过，所以这次来看看Eventbus他是如何通过观察者模式来实现消息总线。

EventBus使用

还是简短总结一下Eventbus他是如何使用的，后面在从这里出发解密源码
Step 1 注册EventBus

EventBus.getDefault().register(this);

Step 2 发送事件

EventBus.getDefault().post("122222");//这里是个例子直接发送了String，在项目中不要这么写，要封装一个专有的Message类

Step 3 订阅事件

@Subscribe(threadMode = ThreadMode.MAIN)
    public void helloEventBus(String text){
        tv.setText(text);
    }

Step 4 解除注册

EventBus.getDefault().unregister(this);

以上就是简单介绍了一下EventBus简单使用，你可能还知道有关粘性事件的，这个我们先不看，我们先从简单的入手。

EventBus源码分析

可以看到注册，发送，解除注册都是通过EventBus.getDefault来调用，先从这里开始看起

1 EventBus构造

/** 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;
    }

标准的DCL单例模式，设置作者还配了一个注释，方便的单例应用程序使用进程范围的EventBus实例，但是我们能发现，EventBus虽然是单例却没有将EventBus构造函数设为private，这里作者也写了一个注释可以完美解释为什么没有私有。

/**
     * Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
     * central bus, consider {@link #getDefault()}.
     */
    public EventBus() {
        this(DEFAULT_BUILDER);
    }

大意就是每new一个EventBus就会存在一个事件总线，如果我们app需要两个事件总线就可以通过new的方式在new出一个新的来使用，并且这两个总线之间的消息互相隔离。所以EventBus没有把构造函数私有，就是为了在使用时你可以选择多条事件总线。继续看这里调用了this构造传入了EventBuilder，这个EventBuilder里初始化了很多变量，我现在先不看他有哪些变量，然后我们继续看看register中做了哪些操作

2 EventBus Register流程

/**
     * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
     * are no longer interested in receiving events.
     * <p/>
     * Subscribers have event handling methods that must be annotated by {@link Subscribe}.
     * The {@link Subscribe} annotation also allows configuration like {@link
     * ThreadMode} and priority.
     */
    public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

在调用register方法时我们传入的参数是this，也就是activity类，我们先看这块代码大致做了什么操作，首先我们获取传入的Class类，然后通过findSubscriberMethods可以通过名字知道他是在查找我们当前这个类的订阅方法，也就是我们在step3实现的接收方法，这个类主要在查找这个方法，然后可以看到下面是一个for循环去对当前activity以及我们的订阅方法进行subscribe。subscribe里面传入了当前suscriber,和被查找出来的subscriberMethod方法，继续看一下subscribe方法。

 private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList<Subscription> 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<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
    }

这段代码可能比较长，不过很好理解，我们还是主要搞清楚他做了什么在去看细节是如何做的，因为我暂时不分析粘性事件，所以这里把粘性事件处理的代码省略了，其实subscribe主要做的就是把我们的消息类型与订阅类存起来，以及订阅函数和订阅类，我这么说可能你会蒙，其实我们注意关注一下，typesBySubscriber和subscriptionsByEventType这两个变量，可以注意到subscribe这个函数都是主要在做对他们两个变量的put操作，而这两个变量是什么呢，

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
//存当前订阅类例如MainActivity.class 和 该类中的订阅函数例如helloEventBus
private final Map<Object, List<Class<?>>> typesBySubscriber;
//存当前订阅类以及事件Event的类型，例：String

这下我们在看整个register我想现在应该有一个大致的思路了，register的时候我们主要做的是把当前注册类以及订阅函数存到subscriptionsByEventType起来，然后再把当前注册类以及发送事件的类型存到typesBySubscriber起来。当然这里面的细节操作就是，通过反射查找订阅类可以详细看SubscriberMethodFinder类。

3 EventBus Post流程

 public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        eventQueue.add(event);
        if (!postingState.isPosting) {
            postingState.isMainThread = isMainThread();
            postingState.isPosting = true;
            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                while (!eventQueue.isEmpty()) {
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

post方法我们知道一般调用之后，事件就会发送给订阅者，然后去执行我们的订阅方法，所以在post方法中一定会调用我们的订阅方法，然后继续看代码，我们先通过currentPostingThreadState.get()去获取了PostingThreadState，这个currentPostingThreadState是什么？

private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

ThreadLocal我们就很熟悉了，他可以再线程中存储变量，并以当前线程为key进行存储，所以第一行是通过当前线程获取当前存储的PostingThreadState，而PostIngThreadState先来看一下数据结构。

final static class PostingThreadState {
        final List<Object> eventQueue = new ArrayList<>();//事件队列
        boolean isPosting; //是否发送
        boolean isMainThread; //是否主线程
        Subscription subscription; //订阅方法
        Object event;//当前发送的事件
        boolean canceled;//是否取消
    }

了解了PostIngThreadState结构之后我们继续看post源码，可以看到post获取到了当前线程的PostIngThreadState，你可以把他想象成一个快递包裹，然后post就开始对快递包裹进行分拣，先对这个包裹的一些状态进行判断，我们可以看到每一个事件来到后，都被存入到了PostingThreadState的eventQueue中，接着又对当前线程以及发送状态做了一些判断后就开始针对事件队列进行处理，可以看到是一个while循环，每一次从下标0的位置取出一个事件开始处理，具体如何处理又要继续看postSingleEvent函数的内容了。

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        if (eventInheritance) {
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }
        if (!subscriptionFound) {
            if (logNoSubscriberMessages) {
                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

按我们所想的这里就应该处理我发出的事件，他去调用我订阅的函数这步了，来看看eventbus是如何处理的，粗略看一下，postSingleEvent里面做了一些判断，这些我们先不关注，可以看到最后都调用了postSingleEventForEventType这个方法，好我们继续看这个，因为这里只是做了一些处理，没有和我们想的去调用订阅函数所以我们先忽略这些处理去看postSingleEventForEventType

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    postToSubscription(subscription, event, postingState.isMainThread);
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

可以粗略看一下其实还是继续处理我们发过来的事件，不过这次通过我们的事件，查找到了订阅方法然后继续交给postToSubscription去处理，还记得subscriptionsByEventType这个变量吧，他是存储了事件类型和订阅方法的map，我们通过它拿到了订阅当前事件的subscriptions对象，然后又把他交给postToSubscription函数处理，

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED:
                if (mainThreadPoster != null) {
                    mainThreadPoster.enqueue(subscription, event);
                } else {
                    // temporary: technically not correct as poster not decoupled from subscriber
                    invokeSubscriber(subscription, event);
                }
                break;
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC:
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

这里根据threadmode来区分不同操作，我直接贴一个引用过来解释一下这四种的含义

1 PostThread：默认的 ThreadMode，表示在执行 Post 操作的线程直接调用订阅者的事件响应方法，不论该线程是否为主线程（UI 线程）。当该线程为主线程时，响应方法中不能有耗时操作，否则有卡主线程的风险。适用场景：对于是否在主线程执行无要求，但若 Post 线程为主线程，不能耗时的操作；
2 MainThread：在主线程中执行响应方法。如果发布线程就是主线程，则直接调用订阅者的事件响应方法，否则通过主线程的 Handler 发送消息在主线程中处理——调用订阅者的事件响应函数。显然，MainThread类的方法也不能有耗时操作，以避免卡主线程。适用场景：必须在主线程执行的操作；
3 BackgroundThread：在后台线程中执行响应方法。如果发布线程不是主线程，则直接调用订阅者的事件响应函数，否则启动唯一的后台线程去处理。由于后台线程是唯一的，当事件超过一个的时候，它们会被放在队列中依次执行，因此该类响应方法虽然没有PostThread类和MainThread类方法对性能敏感，但最好不要有重度耗时的操作或太频繁的轻度耗时操作，以造成其他操作等待。适用场景：操作轻微耗时且不会过于频繁，即一般的耗时操作都可以放在这里；
4 Async：不论发布线程是否为主线程，都使用一个空闲线程来处理。和BackgroundThread不同的是，Async类的所有线程是相互独立的，因此不会出现卡线程的问题。适用场景：长耗时操作，例如网络访问。

在这里我们还是先分析一下如果当前是主线程发布的消息处理流程是什么，因为我们大部分都是在主线程发布的消息，这里先看一下，如果是主线程则会走到下面这个方法

void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

可以注意到这里面用了反射去调用了我们的订阅方法。以上就是整个post流程，现在大致我们可以了解到eventbus是如何去在我们发送事件的时候去调用了我们的订阅方法的。

4 EventBus unRegister流程

 /** Unregisters the given subscriber from all event classes. */
    public synchronized void unregister(Object subscriber) {
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class<?> eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

unregister会做什么，先来想一想，我们在之前register的时候去存储了订阅类和方法的关系map，以及事件类和订阅类的关系map，那么要解除注册当然也要把这两个存入的关系解除，所以看代码第一眼就看到了我们熟悉的一个变量，
typesBySubscriber，这个多次出现过，他是存储了，事件类和订阅类之间关系的变量，可以看到我们传入的变量是一个订阅类，通过它我们能找到他关联的事件类，然后交给unsubscribeByEventType去处理，然后我们继续看unsubscribeByEventType

private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions != null) {
            int size = subscriptions.size();
            for (int i = 0; i < size; i++) {
                Subscription subscription = subscriptions.get(i);
                if (subscription.subscriber == subscriber) {
                    subscription.active = false;
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

又是一个多次出现的变量subscriptionsByEventType，这个是存入的订阅方法以及事件类型的关系map，我们现在通过订阅类查找到了事件类型，再通过事件类型查找到订阅函数，然后将他们的状态改变，在移出，这就是unregister主要做的，其实很简单就是把存入的关系查找到在删除。

总结

粗略的分析了一下eventbus，没有仔细的把每行代码具体做什么分析透，但是大概摸透了eventbus的实现原理，很多细节用到的时候可以再细致查一下，eventbus的确是一个很不错的框架，我在分析的时候略去了很多细节的代码，可能通篇下来有些地方会有很多疑问，这就要具体打开eventbus具体查找了，可能通篇下来还有很多不完善的地方，因为和viewmodel比这个源码就稍微复杂了一些感觉。。可能分析的不好，不过读源码要素我大致已经有一些摸透了，主要就是带着问题，粗略看，摸清小部分的原理在扩大，这样基本读源码读起来没有那么复杂，其实就是把源码划分开然后粗读在细读。