EventBus-3.1.1源码阅读

1. 注册及查找事件

1.1 EventBus初始化

• getDefault： 通过单例模式获取实例，同时里面采用Builder模式构造部分初始化参数，方便定制部分配置信息

  //Builder模式,在EventBusBuilder里面完成一些默认的初始化操作
  private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
  
  public static EventBus getDefault() {
     //通过DCL单例模式创建EventBus实例
  }
  
  public EventBus() {
      this(DEFAULT_BUILDER);
  }
  
  EventBus(EventBusBuilder builder) {
      //通过EventBusBuilder完成的初始化构造
  }
  

1.2 EventBus注册

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

• SubscriberMethod：封装了订阅方法的基本类型信息，即@Subscribe中所注解的内容

  public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
          this.method = method;
          this.threadMode = threadMode;
          this.eventType = eventType;
          this.priority = priority;
          this.sticky = sticky;
      }
  

1.3 查询订阅者所有的订阅方法

• findSubscriberMethods： 查询订阅者所有的订阅方法,三种查询方式：缓存，通过注解器索引，反射

  //METHOD_CACHE缓存了订阅及其所有订阅方法
  private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
  
  List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
      //首先查找缓存
      List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
      if (subscriberMethods != null) {
          return subscriberMethods;
      }
      //ignoreGeneratedIndex默认为false,表示是否忽略注解生成器
      if (ignoreGeneratedIndex) {
          subscriberMethods = findUsingReflection(subscriberClass);//通过反射获取
      } else {
          subscriberMethods = findUsingInfo(subscriberClass);//通过注解的方式
      }
      if (subscriberMethods.isEmpty()) {//如果当前订阅者没有声明订阅方法，则抛出异常
      } else {
          //将订阅者及订阅方法存入缓存中
          METHOD_CACHE.put(subscriberClass, subscriberMethods);
          ...
      }
  }
  

1.3.1 通过注解索引的方式获取订阅者的订阅方法

• findUsingInfo：获取订阅者信息，并且对其父类进行向上查询，最后将所有订阅方法信息封装到subscriberMethods列表中返回

   private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
      FindState findState = prepareFindState();//通过对象池的方式复用FindState
      findState.initForSubscriber(subscriberClass);//初始化参数并将订阅者类信息导入
      while (findState.clazz != null) {
           //获取订阅者信息
          findState.subscriberInfo = getSubscriberInfo(findState);
          //使用了注解索引
          if (findState.subscriberInfo != null) {
              SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
              for (SubscriberMethod subscriberMethod : array) {
                  if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                      findState.subscriberMethods.add(subscriberMethod);//将订阅方法存入
                  }
              }
          } else {
              //未使用注解索引，通过反射查询订阅者的订阅方法
              findUsingReflectionInSingleClass(findState);
          }
           // 将findState.clazz改为subscriberClass的父类Class，再进行遍历
          findState.moveToSuperclass();
      }
      return getMethodsAndRelease(findState);//回收FindState对象到对象池中，并返回subscriberMethods列表
  }
      
  ...
  //实现对象池
  private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];// POOL_SIZE = 4;
  private FindState prepareFindState() {
      synchronized (FIND_STATE_POOL) {
          for (int i = 0; i < POOL_SIZE; i++) {
              FindState state = FIND_STATE_POOL[i];
              if (state != null) {
                  FIND_STATE_POOL[i] = null;
                  return state;
              }
          }
      }
      return new FindState();
  }
  
  

• getSubscriberInfo：遍历订阅者索引，返回查找的订阅者的信息

  private SubscriberInfo getSubscriberInfo(FindState findState) {
      //上面已经有一次判断，所以这个条件不会进入
      if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
          SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
          if (findState.clazz == superclassInfo.getSubscriberClass()) {
              return superclassInfo;
          }
      }
      //遍历订阅者索引，查找订阅者的信息
      if (subscriberInfoIndexes != null) {
          for (SubscriberInfoIndex index : subscriberInfoIndexes) {
              SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
              if (info != null) {
                  return info;
              }
          }
      }
      return null;
  }
  

• FindState 主要用来辅助存储订阅者信息

  static class FindState {
          final List<SubscriberMethod> subscriberMethods = new ArrayList<>();
          final Map<Class, Object> anyMethodByEventType = new HashMap<>();
          final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();
          final StringBuilder methodKeyBuilder = new StringBuilder(128);
          ...
          void moveToSuperclass() { ... }// 修改findState.clazz为subscriberClass的父类Class
  }  
  

1.3.2 通过反射获取订阅者的订阅方法

• findUsingReflection

  //FindState主要用来辅助存储订阅者信息
  private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
      FindState findState = prepareFindState();//通过对象池的方式复用FindState
      findState.initForSubscriber(subscriberClass);//初始化参数并将订阅者类信息导入
      while (findState.clazz != null) {
          findUsingReflectionInSingleClass(findState);//通过反射查询订阅者的订阅方法
          // 将findState.clazz改为subscriberClass的父类Class，再进行遍历
          findState.moveToSuperclass();
      }
      return getMethodsAndRelease(findState);//回收FindState对象到对象池中，并返回subscriberMethods列表
  }
  
  

• findUsingReflectionInSingleClass：通过反射查询订阅者的订阅方法

  private void findUsingReflectionInSingleClass(FindState findState) {
      Method[] methods;
      try {
          // This is faster than getMethods, especially when subscribers are fat classes like Activities
          methods = findState.clazz.getDeclaredMethods();//获取所有声明方法
      } catch (Throwable th) {
          // Workaround for java.lang.NoClassDefFoundError
          methods = findState.clazz.getMethods();
          findState.skipSuperClasses = true;
      }
      for (Method method : methods) {
          int modifiers = method.getModifiers();
          
          //校验方法修饰属性，是否PUBLIC及MODIFIERS_IGNORE
          // MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC;
          
          if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
              Class<?>[] parameterTypes = method.getParameterTypes();//校验方法参数
              if (parameterTypes.length == 1) {
                  //拿到注解信息
                  Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                  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()));
                      }
                  }
              } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                   //抛出异常
              }
          } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
              //抛出异常
          }
      }
  }
  

1.4 注册订阅方法:

• subscribe：将订阅者和订阅方法封装成对象，并将相同事件类型的封装对象根据事件优先级封装到CopyOnWriteArrayList集合中，再将事件类型和CopyOnWriteArrayList封装到map集合中

  Map<Object, List<Class<?>>> typesBySubscriber;
  Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
  Map<Class<?>, Object> stickyEvents = new ConcurrentHashMap<>();
  
  private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
      Class<?> eventType = subscriberMethod.eventType;
      //将订阅者和订阅方法封装成对象
      Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
      //查询出同样事件类型的所有Subscription对象
      CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
  
      //通过CopyOnWriteArrayList对订阅事件对象按事件类型,按照优先级进行存储（同优先级则插入末尾）,并校验是否多次注册（已注册抛出异常）
      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;
          }
      }
      
      //将订阅者对象和订阅事件存储对应存储到map集合中
      List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
      if (subscribedEvents == null) {
          subscribedEvents = new ArrayList<>();
          typesBySubscriber.put(subscriber, subscribedEvents);
      }
      subscribedEvents.add(eventType);
  
      if (subscriberMethod.sticky) {//处理粘性事件
          if (eventInheritance) {
              // 迭代所有事件可能会导致很多粘性事件的效率低下，因此应该更改数据结构以允许更有效的查找
              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);
          }
      }
  }
  

2. 发布通知消息

• post：通过在ThreadLocal中封装一个事件队列，去添加和执行相应的事件

  public void post(Object event) {
      //在ThreadLocal中封装一个线程状态信息，里面包含一个事件队列
      PostingThreadState postingState = currentPostingThreadState.get();
      List<Object> eventQueue = postingState.eventQueue;
      eventQueue.add(event);//将任务添加到事件队列
  
      if (!postingState.isPosting) {
          postingState.isMainThread = isMainThread();
          postingState.isPosting = true;
          if (postingState.canceled) {
              throw new EventBusException("Internal error. Abort state was not reset");
          }
          try {
              while (!eventQueue.isEmpty()) {
                  //遍历发送当前事件队列
                  postSingleEvent(eventQueue.remove(0), postingState);
              }
          } finally {
              postingState.isPosting = false;
              postingState.isMainThread = false;
          }
      }
  }
  private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
          @Override
          protected PostingThreadState initialValue() {
              return new PostingThreadState();
          }
      };
  

• postSingleEvent

  private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
      Class<?> eventClass = event.getClass();
      boolean subscriptionFound = false;
      if (eventInheritance) {
          //遍历查找它的父类添加到列表
          List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
          int countTypes = eventTypes.size();
          for (int h = 0; h < countTypes; h++) {
              Class<?> clazz = eventTypes.get(h);
              //发送该事件
              subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
          }
      } else {
          subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
      }
      ... //找不到事件时异常处理 NoSubscriberEvent
  }
  
  private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
          CopyOnWriteArrayList<Subscription> subscriptions;
          synchronized (this) {
              //获取对应的订阅者
              subscriptions = subscriptionsByEventType.get(eventClass);
          }
          ...
          for (Subscription subscription : subscriptions) {
              postingState.event = event;
              postingState.subscription = subscription;
              boolean aborted = false;
              try {//通知订阅者
                  postToSubscription(subscription, event, postingState.isMainThread);
                  aborted = postingState.canceled;
              } finally {
                  ...//重置postingState属性
              }
              if (aborted)break;
          }
          ...
      }
  

• postToSubscription：通知订阅者，对于不同线程发布消息会调用相应的线程事件队列去执行

  private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
      switch (subscription.subscriberMethod.threadMode) {
          case POSTING:
              //通反射调用过订阅者的方法
              invokeSubscriber(subscription, event);
              break;
          case MAIN:
              if (isMainThread) {
                  invokeSubscriber(subscription, event);
              } else {
                  //如果不是主线程，则加入到主线程执行队列中执行，mainThreadPoster继承自Handler
                  mainThreadPoster.enqueue(subscription, event);
              }
              break;
          case MAIN_ORDERED:
              if (mainThreadPoster != null) {
                  mainThreadPoster.enqueue(subscription, event);
              } else {
                  invokeSubscriber(subscription, event);
              }
              break;
          case BACKGROUND:
              if (isMainThread) {
                  //如果不是后台线程，则加入到后台线程行队列中执行
                  backgroundPoster.enqueue(subscription, event);
              } else {
                  invokeSubscriber(subscription, event);
              }
              break;
          case ASYNC:
              asyncPoster.enqueue(subscription, event);
              break;
          ...
      }
  }
  ...
  void invokeSubscriber(Subscription subscription, Object event) {
      ...
      subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
  }
  
  

3. 发布粘性通知

• postSticky: 粘性事件会通过单独的stickyEvents集合进行存储，同时会在事件订阅的时候进行check post，继而实现粘性这一效果

   public void postSticky(Object event) {
          synchronized (stickyEvents) {
              stickyEvents.put(event.getClass(), event);
              //添加到粘性事件列表，在上述注册订阅方法时，会通过列表去通知信息
          }
          // Should be posted after it is putted, in case the subscriber wants to remove immediately
          post(event);//发布通知，当前已经订阅的订阅者可以收到
      }
      
  ...
  
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
      ...
  
      if (subscriberMethod.sticky) {//处理粘性事件
          if (eventInheritance) {
              // 迭代所有事件可能会导致很多粘性事件的效率低下，因此应该更改数据结构以允许更有效的查找
              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);
          }
      }
  }