EventBus 实现原理

EventBus 是 Android 中比较常用的第三方控件了，具体使用就不写了，分析一下源码实现。

EventBus 的主要实现机制还是基于反射，一句话概括就是：

1. 注册时传入目标类对象，然后利用反射筛选出 @Subscribe 的方法，然后以相同的参数类型为 key，将不同的方法合并为 list 作为 value，得到一个 map 集合；
2. 当用户 post 数据时，再以数据类型为 key，从 map 中取出对应的方法 list，然后遍历 list，再利用反射机制对指定的方法执行 invoke 操作，完成调用；

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

第一步，找到注解方法

下面假设 register 方法传入的是 MainActivity.this，方便理解。

所以很明显，subscriber.getClass() 得到的就是MainActivity 对象，然后进入 findSubscriberMethods 方法。

List findSubscriberMethods(Class subscriberClass) {
    // METHOD_CACHE，缓存 Map，key：当前类，value：类的订阅方法
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
      return subscriberMethods;
    }

    if (ignoreGeneratedIndex) { // 默认为 false
      subscriberMethods = findUsingReflection(subscriberClass);
    } else {
      subscriberMethods = findUsingInfo(subscriberClass);
    }
  
}

// findUsingReflectionInSingleClass
private List findUsingInfo(Class subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
      // 利用反射机制找到目标方法
      findUsingReflectionInSingleClass(findState);
      // 处理完当前类以后再去父类看看
      findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

下面就来到了核心方法：findUsingReflectionInSingleClass

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
      // 根据目标类对象，找到所有方法
      methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
      methods = findState.clazz.getMethods();
      findState.skipSuperClasses = true;
    }
    // 遍历方法集
    for (Method method : methods) {
      int modifiers = method.getModifiers();
      // @Subscribe method: must be public, non-static, and non-abstract
      if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
        Class[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length == 1) {
          // 必须只有一个参数
          Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
          // 拿到 @Subscribe 注解属性
          if (subscribeAnnotation != null) {
            Class eventType = parameterTypes[0];
            if (findState.checkAdd(method, eventType)) {
              // 解析注解属性，即 threadMode, priority, sticky 等，eventType 是方法参数类型
              ThreadMode threadMode = subscribeAnnotation.threadMode();
              // 重新构建一个 SubscriberMethod 对象，添加到 subscriberMethods 集合中
              findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode, subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
            }
          }
        } 
      } 
    }
}

代码走到这里，就完成了第一步的筛选工作：将目标类中所有的 @Subscribe 方法筛选出来，并将其注解属性、参数类型等信息重新包装成 SubscriberMethod 对象，存储到集合中返回。

第二步，订阅绑定

synchronized (this) {
  for (SubscriberMethod subscriberMethod : subscriberMethods) {
    subscribe(subscriber, subscriberMethod);
  }
}

很明显，接下来的重点在 subscribe 方法：

// 以「参数类型」为 key，「Subscription 集合」为 value 的 map 数据集
private final Map, CopyOnWriteArrayList> subscriptionsByEventType;

// 以「目标类对象」为 key，「注册方法参数类集合」为 value 的 map 数据集
private final Map>> typesBySubscriber;

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
  // 注册方法的参数类型，是 map 集合的 key
  Class eventType = subscriberMethod.eventType; 
  // 以目标类（MainActivity）和注解订阅方法重新构建新对象 Subscription
  Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
  // 以 key 值去取出对应的 list 对象
  CopyOnWriteArrayList subscriptions =subscriptionsByEventType.get(eventType);
  if (subscriptions == null) {
    // 如果为空，就初始化数据，然后将数据 put 进去
    subscriptions = new CopyOnWriteArrayList<>();
    subscriptionsByEventType.put(eventType, subscriptions);
  } 

  // 根据 priority 对集合重新进行排序 
  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;
    }
  }

  // 主要用于解注册，与业务无关
  // 根据当前类对象（MainActivity）从 map 中获取集合数据
  List> subscribedEvents = typesBySubscriber.get(subscriber);
  if (subscribedEvents == null) {
    // 如果为空，就初始化集合，然后将 key-value 存入
    subscribedEvents = new ArrayList<>();
    typesBySubscriber.put(subscriber, subscribedEvents);
  }
  // 将当前方法的参数类型存入集合
  subscribedEvents.add(eventType);

  // 如果是粘性事件
  if (subscriberMethod.sticky) {
    if (eventInheritance) { // 默认为 true
      Set, Object>> entries = stickyEvents.entrySet();
      for (Map.Entry, Object> entry : entries) {
        Class candidateEventType = entry.getKey();
        if (eventType.isAssignableFrom(candidateEventType)) {
          Object stickyEvent = entry.getValue();
                // 则会在注册的时候调用注册方法（粘性事件 post 发生在注册以前）
          checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
      }
    } else {
      Object stickyEvent = stickyEvents.get(eventType);
      checkPostStickyEventToSubscription(newSubscription, stickyEvent);
    }
  }
}

整个 EventBus 的注册流程大概就是这样。相对应的，解注册流程就很简单了，只是做了一些常规的清空数据，消除引用，从而避免内存泄漏的操作，就不再具体分析了。

public synchronized void unregister(Object subscriber) {
    // 根据订阅类对象取出当前类中所有的注解方法属性集合 Class -> List
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
      // 遍历循环，对当前类进行解注册
      for (Class eventType : subscribedTypes) {
        unsubscribeByEventType(subscriber, eventType);
      }
      // 将当前类移除
      typesBySubscriber.remove(subscriber);
    } 
}

private void unsubscribeByEventType(Object subscriber, Class eventType) {
  // 根据指定的参数类型，从 map 中取出包含（注册类，注解属性）的 list 集合
  List subscriptions = subscriptionsByEventType.get(eventType);
  if (subscriptions != null) {
    int size = subscriptions.size();
    for (int i = 0; i < size; i++) {
      // 遍历 list，与注册类进行匹配
      Subscription subscription = subscriptions.get(i);
      if (subscription.subscriber == subscriber) {
        subscription.active = false;
        // 找到匹配的数据后，将其从 list 移除，避免内存泄漏
        subscriptions.remove(i);
        i--;
        size--;
      }
    }
  }
}

EventBus#post

说完了注册和解注册，下面来说说 post 动作。post 动作说也简单，实际上就是 method.invoke 的过程。

1. 将事件入队

public void post(Object event) {
  // 维护一个事件发送的状态
  PostingThreadState postingState = currentPostingThreadState.get();
  List