EventBus(二)从源码角度来谈谈设计原理

前言

EventBus是我们常用的第三方框架，主要作用是在各个组件之间进行通信。而且使用起来非常简单，内部原理也并不复杂，如果还不会用的人，可以参考我的这边文章EventBus(一)基础使用。这里对于使用不做说明，我们主要是来看看内部实现方式和原理。

 

源码解析

 

eventBus.getDefault()

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

我们看到，在getDefault()方法里面其实是对EventBus进行了初始化操作。里面运用的是一个双重检索形式的单例模式，确保一次只能实例化一个EventBus对象。最后将这个实例化的对象给返回回来，我们后面做的所有操作都是基于这个对象来操作的。

 

注册对象——register()

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

从注册源码我们可以看到，我们通过findSubscriberMethods()这个方法找到所有的被订阅的方法，即被subscribe修饰的方法，将他们以一个List集合的形式返回回来，之后通过一个for循环，遍历集合中所有被subscribe修饰的方法，将他们放到subscribe()订阅方法里面去处理。

那么EventBus是如何查找到被订阅 的方法的呐？

List findSubscriberMethods(Class subscriberClass) {
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

跳进findSubscribeMethod()这个方法里面去，我们看看里面做了什么操作。可以看到，首先会从一个缓存的Map集合METHOD_CACHE里面查找被订阅的方法，如果能够找得到不为空(null)，则将这个查找出来的List集合返回。如果在缓存里面找不到，则这里会进行一次判断，是从通过索引找还是通过反射来查找。这里需要说明一下，EventBus2.0和3.0的区别就在这里。在2.0时代，EventBus都是通过在运行的时候通过反射来查找所有的订阅方法，而在3.0时代EventBus开始在编译的时候就通过反射来查找，这样比起2.0更加快更有效率。

再来看下findUsingReflection()

    private List findUsingReflection(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findUsingReflectionInSingleClass(findState);
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

private List getMethodsAndRelease(FindState findState) {
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        findState.recycle();
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                if (FIND_STATE_POOL[i] == null) {
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }

我们获取FindState，然后通过while循环从其类和其父类中获取到对订阅的方法，然后将findState放入到getMethodsAndRelease()中，在这个方法里面先new一个list集合，然后我们再次通过for遍历，从里面查找方法，最后将list集合返回回去。

之后通过反射找到了被订阅的事件之后我们将他放入缓存Map集合中并将他return返回回来。之后将结果放入到subscribe()方法中。

// Must be called in synchronized block
    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) {
                // Existing sticky events of all subclasses of eventType have to be considered.
                // Note: Iterating over all events may be inefficient with lots of sticky events,
                // thus data structure should be changed to allow a more efficient lookup
                // (e.g. an additional map storing sub classes of super classes: Class -> List).
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, Object> entry : entries) {
                    Class candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

创建一个subscription来保存订阅者和订阅方法，然后是获取当前订阅事件的集合CopyWriteArrayList，之后通过一个循环按照优先级的高低将这个集合中的订阅事件添加到subscription当中去。到此，所有注册事件全部完毕。

注销对象——unregister()

public synchronized void unregister(Object subscriber) {
        List> 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());
        }
    }

我们看到，在注销方法中没有做什么很深入的操作。整体看来分两步走，一步是移除注册对象和其所有 Event 事件链表，即 typesBySubscriber 移除相关键值对的；再就是在 unsubscribeByEventType() 方法中对 subscriptionsByEventType 移除了该 subscriber 的所有订阅信息（可以看到实际上没有对 METHOD_CACHE 进行相关移除操作，便于下一次注册的时候可以很方便拿到之前的信息，这便是缓存的作用所在）。

 

发射事件对象——post()

 public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List