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 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, List> METHOD_CACHE = new ConcurrentHashMap<>();
  
  List findSubscriberMethods(Class subscriberClass) {
      //首先查找缓存
      List 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 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 subscriberMethods = new ArrayList<>();
          final Map anyMethodByEventType = new HashMap<>();
          final Map subscriberClassByMethodKey = new HashMap<>();
          final StringBuilder methodKeyBuilder = new StringBuilder(128);
          ...
          void moveToSuperclass() { ... }// 修改findState.clazz为subscriberClass的父类Class
  }  
  

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

• findUsingReflection

  //FindState主要用来辅助存储订阅者信息
  private List 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>> typesBySubscriber;
  Map, CopyOnWriteArrayList> subscriptionsByEventType;
  Map, Object> stickyEvents = new ConcurrentHashMap<>();
  
  private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
      Class eventType = subscriberMethod.eventType;
  	//将订阅者和订阅方法封装成对象
      Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
  	//查询出同样事件类型的所有Subscription对象
      CopyOnWriteArrayList 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> subscribedEvents = typesBySubscriber.get(subscriber);
      if (subscribedEvents == null) {
          subscribedEvents = new ArrayList<>();
          typesBySubscriber.put(subscriber, subscribedEvents);
      }
      subscribedEvents.add(eventType);
  
      if (subscriberMethod.sticky) {//处理粘性事件
          if (eventInheritance) {
              // 迭代所有事件可能会导致很多粘性事件的效率低下，因此应该更改数据结构以允许更有效的查找
              Set, Object>> entries = stickyEvents.entrySet();
              for (Map.Entry, 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