EventBus3.0源码学习(1) register和unregister

引子

EventBus提供了一套完善的总线机制，能有效地用于模块间解耦。要使用EventBus，在项目模块的build.gradle中添加如下依赖即可：

dependencies {
    compile 'org.greenrobot:eventbus:3.0.0'
}

类定义

public class EventBus {

    static volatile EventBus defaultInstance;

    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
    private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<>();

    private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
    private final Map<Object, List<Class<?>>> typesBySubscriber;
    private final Map<Class<?>, Object> stickyEvents;

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

    private final HandlerPoster mainThreadPoster;
    private final BackgroundPoster backgroundPoster;
    private final AsyncPoster asyncPoster;
    private final SubscriberMethodFinder subscriberMethodFinder;
    private final ExecutorService executorService;

    private final boolean throwSubscriberException;
    private final boolean logSubscriberExceptions;
    private final boolean logNoSubscriberMessages;
    private final boolean sendSubscriberExceptionEvent;
    private final boolean sendNoSubscriberEvent;
    private final boolean eventInheritance;

    private final int indexCount;

    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

    public EventBus() {
        this(DEFAULT_BUILDER);
    }

    EventBus(EventBusBuilder builder) {
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        stickyEvents = new ConcurrentHashMap<>();
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
        backgroundPoster = new BackgroundPoster(this);
        asyncPoster = new AsyncPoster(this);
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }
}

注册(register)

当一个对象想要从EventBus接收事件时，只需在EventBus中进行注册自己，调用EventBus.getDefault().register(this)即可。register的实现如下：

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

第3行，查找subscriber对应的类中所有接收EventBus事件的函数，然后依次调用subscribe函数注册这些所有查到的函数。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);

    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<Class>).
            Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry<Class<?>, 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);
        }
    }
}

第3行，subscriber和subscriberMethod被封装成一个Subscription对象，Subscription描述了subscriber通过subscriberMethod对EventBus的一个事件订阅。

第4-21行，subscriptionsByEventType存储了<eventType, subscriptions>的映射关系，当分发事件时，使用该Map可以快速找到订阅了该事件的所有对象及其用于处理该事件的方法。subscriptions中的subscription，可能来自不同类的对象、同一类的不同对象、甚至同一个对象的不同方法，subscriptions以subscriberMethod.priority维护它们的降序顺序。对同一个对象的重复注册会导致第10行抛出EventBusException异常。

第23-28行，typesBySubscriber存储了<subscriber, subscribedEvents>的映射关系，当取消注册时，使用该Map可以快速找到该对象订阅的所有事件，或 判断该对象是否已经注册过了。

第30-48行，stickyEvents存储了<eventType, stickyEvent>的映射关系，与普通事件不同，除非显示移除，否则EventBus中总是保留该类事件的最近一次事件实例。当subscriberMethod.sticky为true，从stickyEvents中查找eventType对应的stickyEvent发送给该对象。若eventInheritance为true，查找stickyEvents中所有eventType及其子类的事件进行发送。

取消注册(unregister)

当一个类不再需要接收EventBus时，它需要在EventBus中取消注册，即调用EventBus.getDefault().unregister(this)。这很重要，在实际开发中，很多内存泄漏问题都是由于注册之后没有取消注册导致的。unregister的实现如下：

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 {
        Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

使用typesBySubscriber查找subscriber订阅了的所有事件类型，依次调用unsubcribeByEventType函数取消subscriber对每个eventType的订阅，然后将subscriber从typesBySubscriber中移除。unsubcribeByEventType的实现如下：

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查找eventType对应的subscriptions，然后移除subscriptions中所有subscription.subscriber==subscriber的subscription，并将subscription.active置为false。

总结

EventBus中与事件分发相关的底层实现主要涉及三个Map：

• subscriptionsByEventType--<eventType, subscriptions>，主要用于事件分发，用于快速找到event的订阅者集合；
• typesBySubscriber--<subscriber, eventType>，主要用于取消注册，用于快速查找对象订阅的事件类集合；
• stickyEvents保存了stickyEvent的最近一次事件实例。