Android EventBus3.0+源码分析

EventBus，EventBus Index - apt

本文将从EventBus 创建 - > 注册--->发送消息--->解除注册 几个方面来读一下EventBus 3.0+ 的源码。
EventBus 简单订阅 (例如，在MainActivity.class ，注册String.class 类型的事件) 代码如下：

//MainActivity.class

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //....
        
        EventBus.getDefault().register(this);
    }



//类中的，订阅方法， 事件类型为String
    @Subscribe(threadMode = ThreadMode.MAIN, priority = 100, sticky = false)
    public void onStringEvent(String eventString) {

    }

上面代码在别的地方发送 事件类型为 String.class 则会调用到 MainActivity#onStringEvent 方法。

一、EventBus 创建

EventBus.getDefault(); // 返回的是EventBus对象

这里的 EventBus.getDefault() 其实是拿到的EventBus对象，其中涉及到了一个 线程安全的单利模式，代码如下（参数解释标注在了注释中）：

EventBus.java

static volatile EventBus defaultInstance;
//线程安全的单例模式
     public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {//加锁
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();  //如果不存在，则去创建
                }
            }
        }
        return defaultInstance; 
    }

如果不存在，就走下面的创建方法：

EventBus.java

//创建过程
  EventBus(EventBusBuilder builder) {
      
        //private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
        //key:订阅的事件,value:订阅这个事件的所有订阅者集合
        subscriptionsByEventType = new HashMap<>();

        //private final Map>> typesBySubscriber;
        //key:订阅者对象,value:这个订阅者订阅的事件集合
        typesBySubscriber = new HashMap<>();
        
        //粘性事件 key:粘性事件的class对象, value:事件对象
        //private final Map, Object> stickyEvents;
        stickyEvents = new ConcurrentHashMap<>();
      
        //ui线程的 Handler
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
      
        //Background 处理
        backgroundPoster = new BackgroundPoster(this);

        //异步事件处理
        asyncPoster = new AsyncPoster(this);

        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

二、EventBus注册

1，使用（下面的this，就是上面例子中的 MainActivity.class）

//最常用的EventBus注册
EventBus.getDefault().register(this);

1.1 主要看 EventBus.java ->register()

EventBus.java

/**
     * 大概翻译一下，该方法上的注释的意思。
     * 1，记得调用 {@link #unregister(Object)} 进行注册解除
     * 2，订阅者，需要有一个包含 {@link Subscribe} 注解的方法。
     */
    public void register(Object subscriber) {
        //1，拿到订阅的class  上面例子中的 `MainActivity.class`
        Class subscriberClass = subscriber.getClass();
        //2，通过subscriberMethodFinder来找到订阅者订阅了哪些事件.返回一个SubscriberMethod对象的List,SubscriberMethod
        //里包含了这个方法的Method对象,以及将来响应订阅是在哪个线程的ThreadMode,以及订阅的事件类型eventType,以及订阅的优
        //先级priority,以及是否接收粘性sticky事件的boolean值.
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //3，从步骤2得到的集合，说明一个类中可能有很多个订阅方法，在下面通过foreach依次 订阅。
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                //
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

1.2 跟到：SubscriberMethodFinder.java --> findSubscriberMethods()方法中，可以理解为：寻找到 类中所有带@Subscribe注解的方法

/**
 * METHOD_CACHE 本质是一个 key = class ，value = List 的线程安全的map集合。
 */
private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();

//-------------------------------------------------
List findSubscriberMethods(Class subscriberClass) {
        //METHOD_CACHE ：缓存，先从缓存中获取
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            //如果不为null，说明之前缓存的Map集合中有，直接return，返回
            return subscriberMethods;
        }
        
        //ignoreGeneratedIndex  默认是 false
        if (ignoreGeneratedIndex) {
            // 使用反射方式获取(反射继续跟会到这个方法中：findUsingReflectionInSingleClass(findState);，在这个方法中，通过@Subscriber注解，找到相应的方法)
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 使用SubscriberIndex方式获取
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
        //在这里也可以看到，如果没有一个  声明为 public + 含有 @Subscribe 的方法，就会抛异常！
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the  @Subscribe annotation");
        } else {
            //在这里，将传入的class 作为key，存到 subscriberMethods 中。
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

由于ignoreGeneratedIndex 默认是 false，则进入 else 中分析findUsingInfo() 方法：

private List findUsingInfo(Class subscriberClass) {
        FindState findState = prepareFindState();
        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);
    }

• getSubscriberInfo(findState); 该方法默认为null，因为，在 findState.initForSubscriber(subscriberClass) 初始化的时候，findState.subscriberInfo = null 第一个 if 判断不会走。subscriberInfoIndexes 涉及到了 apt ，默认也是 null (可以进入 EventBusBuilder # addIndex() 进行验证)

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

1.3 继续看 findUsingReflectionInSingleClass ， 找到 添加注解方法的核心(关键代码在注解中进行解释)

// SubscriberMethodFinder.java


private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 这里的 clazz 也就是平常我们写的类，如：MainActivity等等
            //反射，得到 类 方法的数组
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        //遍历方法，找到包含注解的方法 （上面例子中 `onStringEvent(String eventString)` 方法)
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //判断修饰符，是不是 public
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                 //保证必须只有一个参数，其实就是注解方法中只能有一个事件（上面例子中的 String.class 类型）
                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)) {
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

总结：
上面步骤主要做的是，找到订阅class中的订阅方法 SubscriberMethod，并保存。

继续分析 EventBus.java ->register() --> subscribe() 订阅方法

//这里的 subscriber(订阅者) 也就是 `MainActivity.class` ， 
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取方法参数事件的 class ，例如上面例子的：`String.class`
        Class eventType = subscriberMethod.eventType;
        //创建Subscription对象
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //从subscriptionsByEventType里检查是否已经添加过该Subscription,如果添加过就抛出异常
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        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);
            }
        }
        //根据优先级priority来添加Subscription对象，ps：优先级越大越靠前
        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;
            }
        }
        //将订阅者对象以及订阅的事件保存到typesBySubscriber里.
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //如果接收sticky事件,立即分发sticky事件
        if (subscriberMethod.sticky) {
            //eventInheritance 表示是否分发订阅了响应事件类父类事件的方法
            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);
            }
        }
    }

• Map, CopyOnWriteArrayList> subscriptionsByEventType;：key：代表的是事件类型，如String.class；value：线程安全的List,保存的是一组订阅该(String.class)事件的订阅。通俗来说就是：String.class 事件可能被 A B C...等等类订阅，这个List就是订阅String.class所有集合。
  完成以上过程就完成了注册过程。

• 黏性事件，在EventBus # subscribe 方法中，如果sticky = true，则会直接调用该类中的sticky = true订阅方法，具体实现在EventBus # checkPostStickyEventToSubscription 方法中。
  注意：黏性事件，如果不需要接收，则需要调用 EventBus.getDefault().removeStickyEvent() 进行事件移除，否则每次进入该页面，都会收到该事件。

https://www.jianshu.com/p/f057c460c77e .png

三、EventBus 事件发送过程

EventBus 通过调用 post(普通事件)、postSticky(粘性事件) 来发送事件。

image.png

EventBus.java

    public void post(Object event) {
        //获得当前发送线程相关状态(ThreadLocal保证线程安全)
        PostingThreadState postingState = currentPostingThreadState.get();
        //将事件添加到队列中
        List