分析EventBus源码扩展Weex事件机制[源码]

分析EventBus源码扩展Weex事件机制

EventBus 是基于观察者模式的发布/订阅事件总线，它让组件间的通信变得更加简单。类似广播系统，不过 EventBus 所有的订阅和发送都是在内存层面的，使用起来远比广播简单，也更容易管理。

EventBus-Publish-Subscribe.png

先说明在事件总线中的几个关键词：

• 事件发送者，发出事件的人
• 订阅者，处理事件的人
• 订阅者中处理事件的方法，因为每个订阅者感兴趣的事件有多种，因此会有多个处理事件的方法
• 订阅，一个订阅指的是某个订阅者中的处理某个事件的方法，由订阅者和事件类型唯一确定。

订阅事件注册

当希望接受到事件时，需要在 onCreate() 执行 register() 方法，在注册方法中会检索当前类中声明的接受事件的方法，并将他们注册到对应的映射中。

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

内存中存储的数据结构有如下几个：

// 事件 - List<订阅(Subscription)> 每个订阅由订阅者、事件类型唯一确定
private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
// 订阅者 - List<关注的事件> 每个订阅者可能关注多个事件
private final Map>> typesBySubscriber;
// 事件对应下的粘滞事件
private final Map, Object> stickyEvents;

查找订阅方法列表

当执行 register() 方法时，会借助 SubscriberMethodFinder 类从注册的对象的 Class 中查找。

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()) {
        // 没有找到任何的订阅方法将会抛出异常，所以至少要用注解订阅一个方法
    } else {
        // 针对这个 class 查找到订阅的方法列表，存缓存，下次更快的返回
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}

因为我们不考虑索引的情况，最终查找方法都会走到方法 findUsingReflectionInSingleClass，内部的原理相对简单，遍历该类的所有方法，找到共有的、只有一个参数、且带有 @Subscribe 注解的方法，存储到列表中。

private static final int MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC;

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    methods = findState.clazz.getDeclaredMethods();    
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        // 共有的方法 & 不是静态、抽象、不是编译生成的方法
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
            Class[] parameterTypes = method.getParameterTypes();
            // 参数长度只能是1
            if (parameterTypes.length == 1) {
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                // 方法上面带有 @Subscribe 注解
                if (subscribeAnnotation != null) {
                    Class eventType = parameterTypes[0];
                    if (findState.checkAdd(method, eventType)) {
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }
            }
        }
    }
}

这个过程是一个循环，每次都会向上查找当前类的父类，知道到达 java 内置的类中，这就意味着，父类中声明的订阅方法，在子类实例中也会接收到。查找的结果最终会生成一个 SubscriberMethod 的列表，这个类中存储了订阅方法的全部信息，数据结构如下：

public class SubscriberMethod {
    final Method method; // 当前的方法，可执行
    final ThreadMode threadMode; // 线程类型
    final Class eventType; // 参数的类型，也就是他订阅的事件的类型
    final int priority; // 优先级
    final boolean sticky; // 是否是粘滞事件
    String methodString; // 方法的字符串
}

订阅到映射中

// 事件 - List<订阅(Subscription)> 每个订阅由订阅者、事件类型唯一确定
private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
// 订阅者 - List<关注的事件> 
private final Map>> typesBySubscriber;

订阅的过程就是根据订阅者 Subscriber 及该订阅者的某个处理事件的方法 SubscriberMethod 来生成 Subscription 并且存储到映射当中。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    // 存储到 事件 - List<订阅> 映射中
    Class eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(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<关注的事件> 映射中
    List> subscribedEvents = typesBySubscriber.get(subscriber); // ... 不存在则创建新的
    subscribedEvents.add(eventType);
    // ...
    // 对 Sticky Event 的处理，后面单独说
}

取消注册

由于事件总线的机制基于内存实现，所有的订阅都会存储在内存中，因此必须在合适的时机取消注册，来释放占用的内存空间。

当取消注册时：

• 借助之前存储的 订阅者-List<关注事件> 的映射快速的获取到，当前订阅者感兴趣的事件列表。
• 然后遍历事件列表，从 事件-List<订阅> 的映射中，删除所有的订阅。
• 最后将当前订阅者从 订阅者-List<关注事件> 删除，完成取消订阅的过程。

获取当前订阅者关注的全部事件，遍历取消注册。

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 {
    }
}

// 从订阅列表中删除对应的订阅
private void unsubscribeByEventType(Object subscriber, Class eventType) {
    List 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--;
            }
        }
    }
}

发送事件

当需要发送事件使用 EventBus 的 post() 方法。

借助 ThreadLocal 每个线程单独维护一个、且仅一个 PostingThreadState 对象，这个对象的数据结构如下, 内部存储了当前发送事件状态的的一些关键信息。

final static class PostingThreadState {
    final List