学习EventBus之订阅

相信做Android开发的很少有没听说过EventBus的，如果真没听过那只能说明你Out了。EventBus是针对Android平台优化了的发布/订阅事件总线，它的目的是简化Android组件以及线程间的通信，从而使代码更加简洁。

官方给的流程图

简单使用

• 定义事件类型
  public class MessageEvent{}
• 订阅者订阅事件
  eventBus.register(this)
• 发送事件
  eventBus.post(messageEvent)

通过以上三步，就完成一次完整的EventBus使用流程。

其实类似这种发布/订阅的机制在生活中用的也挺多的。比如我晚上定个8点的闹钟，就相当于订阅了一个事件，这个事件就是’8点钟的闹钟’。当第二天8点闹钟响的时候，就相当于发送了事件。我就会收到这个事件，然后执行相应的动作，比如起床。

那么，既然是订阅/发布。肯定就会有订阅，有发布了。这篇文章先根据源码来研究下订阅事件的流程和原理。

一般我们都会像这样EventBus.getDefault().register(this)使用EventBus。这里首先会创建一个默认的EventBus对象，然后调用EventBus的register(Object subscriber)方法将当前类作为订阅者进行事件的订阅。

/** Convenience singleton for apps using a process-wide EventBus instance. */
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的实例的。从注释中看以看到，这个实例的作用于为整个进程。

这里的关键点就是register(Object subscriber)方法了，上源码：

public void register(Object subscriber) {
    register(subscriber, false, 0);
}

private synchronized void register(Object subscriber, boolean sticky, int priority) {
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());
    for (SubscriberMethod subscriberMethod : subscriberMethods) {
        //遍历所有订阅方法进行订阅
        subscribe(subscriber, subscriberMethod, sticky, priority);
    }
}

可以看到register(Object subscriber)方法内部调用了重载的方法register(Object subscriber, boolean sticky, int priority)，所有的逻辑都在这个重载的方法内部实现。

首先执行subscriberMethodFinder.findSubscriberMethods(subscriber.getClass())，我们跟踪到findSubscriberMethods(Class<?> subscriberClass)方法内部去看看。

//寻找subscriberClass中所有的订阅方法
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    String key = subscriberClass.getName();
    List<SubscriberMethod> subscriberMethods;
    synchronized (methodCache) {//先从缓存中根据类名找对应的方法，如果没找到说明这个类之前没有注册过
        subscriberMethods = methodCache.get(key);
    }
    if (subscriberMethods != null) {//如果找到了则直接返回，不用再查找了
        return subscriberMethods;
    }
    subscriberMethods = new ArrayList<SubscriberMethod>();
    Class<?> clazz = subscriberClass;
    HashMap<String, Class> eventTypesFound = new HashMap<String, Class>();
    StringBuilder methodKeyBuilder = new StringBuilder();
    while (clazz != null) {
        String name = clazz.getName();
        if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {//排除系统的一些类
    // Skip system classes, this just degrades performance
        break;
}

    // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)
        try {
        // This is faster than getMethods, especially when subscribers a fat classes like Activities
                Method[] methods = clazz.getDeclaredMethods();//拿到订阅者中声明的所有方法
                filterSubscriberMethods(subscriberMethods, eventTypesFound, methodKeyBuilder, methods);//对方法进行过滤，找到符合订阅规则的订阅方法
            } catch (Throwable th) {
                th.printStackTrace();
                // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
                Method[] methods = subscriberClass.getMethods();
                subscriberMethods.clear();
                eventTypesFound.clear();
                filterSubscriberMethods(subscriberMethods, eventTypesFound, methodKeyBuilder, methods);
                break;
            }
            clazz = clazz.getSuperclass();
        }
        if (subscriberMethods.isEmpty()) {//查找完后如果没找到，报异常：该类订阅了EventBus，但没有对应的订阅方法
            throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called "
                    + ON_EVENT_METHOD_NAME);
        } else {
            synchronized (methodCache) {//如果找到了，则存起来。防止重复查找。这里的key就是方法名
                methodCache.put(key, subscriberMethods);
            }
            return subscriberMethods;
        }
    }
//对方法进行过滤，筛选出符合事件接收的方法 形如 "public void onEvent**(Object event)"
private void filterSubscriberMethods(List<SubscriberMethod> subscriberMethods,                                         HashMap<String, Class> eventTypesFound, StringBuilder methodKeyBuilder,                                         Method[] methods) {
                                         HashMap<String, Class> eventTypesFound, StringBuilder methodKeyBuilder,
                                         Method[] methods)
    for (Method method : methods) {
        String methodName = method.getName();
        if (methodName.startsWith(ON_EVENT_METHOD_NAME)) {//方法以onEvent开头
            int modifiers = method.getModifiers(); //方法的限定符类型 public  private等
            Class<?> methodClass = method.getDeclaringClass();//声明方法的类
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                //方法是public的 且非abstract static （bridge synthetic 这两个啥意思？)
                Class<?>[] parameterTypes = method.getParameterTypes(); //方法参数类型
                if (parameterTypes.length == 1) {//方法只有一个参数
                    ThreadMode threadMode = getThreadMode(methodClass, method, methodName);
                    if (threadMode == null) {//不是订阅方法，继续迭代下一个方法
                        continue;
                    }
                    Class<?> eventType = parameterTypes[0];
                    methodKeyBuilder.setLength(0);
                    methodKeyBuilder.append(methodName);
                    methodKeyBuilder.append('>').append(eventType.getName());
                    String methodKey = methodKeyBuilder.toString();
                    Class methodClassOld = eventTypesFound.put(methodKey, methodClass);//以方法名和event类型名作为key
                                                                                        //存入订阅方法列表中
                    if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                        // Only add if not already found in a sub class
                        subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType));
                    } else {
                        // Revert the put, old class is further down the class hierarchy
                        eventTypesFound.put(methodKey, methodClassOld);
                    }
                }
            } else if (!skipMethodVerificationForClasses.containsKey(methodClass)) {
                Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + methodClass + "."
                        + methodName);
            }
        }
    }
}

//判断订阅方法需要在哪个线程中调用
private ThreadMode getThreadMode(Class<?> clazz, Method method, String methodName) {
    String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.length());//截取方法名中onEvent后的字符
                                                                                    //如 onEventMainThread -> MainThread
    ThreadMode threadMode;
    if (modifierString.length() == 0) { //方法名为onEVent 默认在PostThread中调用
        threadMode = ThreadMode.PostThread;
    } else if (modifierString.equals("MainThread")) {//方法名为onEVentMainThread 在MainThread中调用
        threadMode = ThreadMode.MainThread;
    } else if (modifierString.equals("BackgroundThread")) {//方法名为onEVentBackgroundThread 在BackgroundThread中调用
        threadMode = ThreadMode.BackgroundThread;
    } else if (modifierString.equals("Async")) {//方法名为onEVentAsync 异步调用
        threadMode = ThreadMode.Async;
    } else {//如果不是以上几个选择 认为不是订阅方法 threadMode为null
        if (!skipMethodVerificationForClasses.containsKey(clazz)) {
                throw new EventBusException("Illegal onEvent method, check for typos: " + method);
        } else {
            threadMode = null;
        }
    }
    return threadMode;
}

上面代码比较长，注释的已经很清楚了。findSubscriberMethods(Class<?> subscriberClass)执行完之后，就找到了订阅者类中所有的能够接受事件的方法并存了起来。

我们继续回到register(Object subscriber, boolean sticky, int priority)方法中，查询完订阅方法后，对所有的方法进行迭代，然后调用subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority)进行一一注册。

// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {
    Class<?> eventType = subscriberMethod.eventType;
    //根据事件类型取出该类事件的所有订阅者
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority);
    if (subscriptions == null) {//如果没有该类型的订阅者 创建一个 加入列表
        subscriptions = new CopyOnWriteArrayList<Subscription>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
        if (subscriptions.contains(newSubscription)) {//如果所有订阅者中已经包含新加入的这个订阅者，提示已经订阅了
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                    + eventType);
        }
    }

    // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)
    // subscriberMethod.method.setAccessible(true);

    int size = subscriptions.size();
    //遍历所有的订阅者 按照优先级(Subscription的priority属性)进行排序
    for (int i = 0; i <= size; i++) {
        if (i == size || newSubscription.priority > subscriptions.get(i).priority) {
            subscriptions.add(i, newSubscription);
            break;
        }
    }

    //取出某个订阅者中所有的订阅事件
    List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<Class<?>>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);

    if (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);
        }
    }
}

当subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority)方法执行完之后，所有的订阅者以及订阅者中的事件接受方法就被存起来了。

//按事件类型存放的订阅者集合
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
//按订阅者类型存放的事件集合
private final Map<Object, List<Class<?>>> typesBySubscriber;
//黏性事件(这个怎么理解？)
private final Map<Class<?>, Object> stickyEvents;

至此，事件的订阅就完成了。最终的结果就是EventBus保存了订阅者中所有符合规则(即public void onEvent***(Object event))的能接收事件的方法。当post事件的时候，就会拿着这个事件去保存的订阅者方法中去对比寻找，找到后通过反射去调用对应的方法。