【EventBus】EventBus 源码解析 ( 注册订阅者 | 订阅方法 | 查找订阅方法 )

/**
 * EventBus是Java和Android的中央发布/订阅事件系统。
 * 事件被发布（{@link#post（Object）}）到总线，总线将其传递给具有匹配处理程序的订阅者
 * 事件类型的方法。
 * 要接收事件，订阅者必须使用{@link#register（Object）}将自己注册到总线。
 * 一旦注册，订阅服务器将接收事件，直到调用{@link#unregister（Object）}。
 * 事件处理方法必须由{@link Subscribe}注释，必须是公共的，不返回任何内容（void），
 * 并且只有一个参数（事件）。
 */
public class EventBus {
    /**
     * 注册给定订阅服务器以接收事件。订阅者一旦对接收事件不再感兴趣，就必须调用{@link#unregister（Object）}。
     * <p/>
     * 订阅服务器具有必须由{@link Subscribe}注释的事件处理方法。
     * {@link Subscribe}注释还允许类似{@link ThreadMode}和优先级的配置。
     */
    public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        // 1. 获取 订阅者 集合 , 查找当前订阅类中符合条件的订阅方法集合 
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        // 2. 遍历 订阅者 集合 , 进行事件订阅 , 保存数据 , 这些数据就是一些映射关系 
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }
}

/** 由EventBus内部使用并生成订户索引。 */
public class SubscriberMethod {
    final Method method;
    final ThreadMode threadMode;
    final Class<?> eventType;
    final int priority;
    final boolean sticky;
    /** Used for efficient comparison */
    String methodString;
}

class SubscriberMethodFinder {
  // 方法缓存集合
    private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
      // 从缓存中获取 订阅方法 , METHOD_CACHE 缓存是一个 HashMap 集合
      //  如果订阅者有很多方法 , 如果每次订阅都要查询所有的方法 , 很消耗性能 
      //  第一次订阅时 , 将方法都放在集合中 
      //  如果第二次订阅 , 不用再次查找方法
        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()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }
}

class SubscriberMethodFinder {
    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
      // FindState 是辅助类 , 其中进行了状态保存等信息 
        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.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }
}

class SubscriberMethodFinder {
    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
          // 通过反射获取订阅者类中的所有方法 
            // 这比getMethods快，特别是当订阅者是像 Activity 这样的大类时
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
        }
        // 遍历 订阅者 类中的所有方法 , 过滤掉不符合条件的方法 , 
        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 注解 
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                      // @Subscribe 注解属性判断 
                        Class<?> eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                          // @Subscribe 注解线程模式判断
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            // 将符合条件的方法封装到 findState.subscriberMethods 集合中 ; 
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } 
            } 
        }
    }
}