说起 EventBus，作为一名 Android 开发者，应该不会太陌生，但是我们大部分都会根据官方文档直接进行使用，其实还有一种比较高效的使用方式。就是不使用注解的方式，在编译时期，对相关注册方法进行注册。
这其实就相当于用空间换时间的一种常规操作了。这里附上 官方源码 和 官方文档 的地址。
先来贴一张官方文档中的图解，让大家对 EventBus 的工作机制现有一个宏观上的回忆。
先来看看常规的使用方式。
1、接入EventBus
implementation 'org.greenrobot:eventbus:3.2.0'2、使用
//1、创建订阅事件 class DataModel(val msg: String) class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) //2、注册订阅 EventBus.getDefault().register(this) } //3、创建接收发布的事件的方法 @Subscribe(threadMode = org.greenrobot.eventbus.ThreadMode.MAIN, sticky = true, priority = 2) fun dataReceive(dataModel: DataModel) { Toast.makeText(this, dataModel.msg, Toast.LENGTH_LONG).show() } fun post(view: View) { //4、发布事件 EventBus.getDefault().post(DataModel("send success")) } override fun onDestroy() { //5、取消订阅 EventBus.getDefault().unregister(this) super.onDestroy() } }使用方式很简单，基本上和官方介绍的一样，为了方便就在这里聚合了一下。 下面来分析这种方式，是怎么实现订阅者与发布者之间进行信息交互的。
在分析具体源码之前，先来看看几个相关的辅助类
1、Subscribe 作用于订阅事件方法的注解类
//运行时 @Retention(RetentionPolicy.RUNTIME) //目标作用于方法 @Target({ElementType.METHOD}) public @interface Subscribe { //线程模式，有当线程、主线程、子线程、异步线程等。 ThreadMode threadMode() default ThreadMode.POSTING; //是否为粘性事件，就是可以先进行发布，后进行注册，注册时候会立刻收到发布的事件 boolean sticky() default false; //接受的优先级，数值越大优先级越高 int priority() default 0; }2、Subscription、SubscriberMethod 订阅方法的封装类
final class Subscription { //订阅的对象，例如上面的 MainActivity 对象（这里需要注意，不是类，而是具体的对象） final Object subscriber; //注册类中的订阅方法（与对象无关，解析相关类中的订阅方法） final SubscriberMethod subscriberMethod; } public class SubscriberMethod { //订阅的方法名 final Method method; //执行的线程环境 final ThreadMode threadMode; //订阅事件类型（订阅方法中的参数类型） final Class<?> eventType; //优先级 final int priority; //是否为粘性事件 final boolean sticky; //用于比较两个方法是否相同，具体在继承中会用到 String methodString; }基于上面的使用方法，我们可以直接从第二步的注册订阅事件的 register() 方法来进行源码的跟踪。
先来看看注册事件
public class EventBus { //订阅方法的集合：<订阅类型，该类型的多有方法集合>，方便用于事件分发 private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType; //订阅方法的集合：<订阅者对象，该类中的所有注册方法>，方便用于去掉订阅 private final Map<Object, List<Class<?>>> typesBySubscriber; //所有的粘性事件集合：<订阅事件类型，事件对象>，用于后续新事件注册后的粘性事件分发 private final Map<Class<?>, Object> stickyEvents; public void register(Object subscriber) { Class<?> subscriberClass = subscriber.getClass(); //从注册类中找出所有订阅事件的相关方法 //下文在分析 SubscriberMethodFinder 这个辅助类，这里先跳过，看注册的主流程 List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass); synchronized (this) { for (SubscriberMethod subscriberMethod : subscriberMethods) { subscribe(subscriber, subscriberMethod); } } } private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) { Class<?> eventType = subscriberMethod.eventType; Subscription newSubscription = new Subscription(subscriber, subscriberMethod); //拿到当前订阅事件type的订阅集合 CopyOnWriteArrayList<Subscription> 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); } } //将当前订阅方法添加到当前的订阅集合中，并根据优先级进行排序 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; } } //拿到订阅对象的集合 List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber); if (subscribedEvents == null) { subscribedEvents = new ArrayList<>(); typesBySubscriber.put(subscriber, subscribedEvents); } //将订阅事件添加到订阅对象的集合中 subscribedEvents.add(eventType); if (subscriberMethod.sticky) { ...... //如果是粘性事件，则判断是否需要进行派发 //这也就是为什么可以先发布事件，后面进行注册也可以收到发布事件的原因了 //每次新注册方法时都会判断是否需要进行粘性事件的分发 checkPostStickyEventToSubscription(newSubscription, stickyEvent); ...... } } private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) { if (stickyEvent != null) { postToSubscription(newSubscription, stickyEvent, isMainThread()); } } private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) { ...... invokeSubscriber(subscription, event) ...... } void invokeSubscriber(Subscription subscription, Object event) { try { //使用反射进行相应事件的调用 subscription.subscriberMethod.method.invoke(subscription.subscriber, event); } catch (InvocationTargetException e) { handleSubscriberException(subscription, event, e.getCause()); } catch (IllegalAccessException e) { throw new IllegalStateException("Unexpected exception", e); } } }下面来看下上文中略过的 SubscriberMethodFinder 辅助类。
这个类的作用就是从传入的注册类中找出订阅方法的集合并返回。
class SubscriberMethodFinder { private static final int MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC; //从缓存中查找是否曾经注册过，如果有则直接返回 private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>(); //这里就是上文中注册方法调用的方法，根据订阅的 class 寻找该类中的所有订阅方法 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) { List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass); if (subscriberMethods != null) { return subscriberMethods; } if (ignoreGeneratedIndex) { //使用反射寻找，由于没有进行任何相关配置，所以默认会使用反射进行查找，所以效率相对来说比较底下 subscriberMethods = findUsingReflection(subscriberClass); } else { //使用添加的信息寻找 //这里后文分析高效使用时，在进行分析 subscriberMethods = findUsingInfo(subscriberClass); } if (subscriberMethods.isEmpty()) { //如果注册的类中没有订阅方法，则直接抛出异常。这就有点坑，容易出bug 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; } } private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) { FindState findState = prepareFindState(); findState.initForSubscriber(subscriberClass); //循环遍历当前类和父类，通过反射查找相应的订阅方法 while (findState.clazz != null) { //查找当前类的订阅方法 findUsingReflectionInSingleClass(findState); //查找完毕后，将当前 class 定位到父类 findState.moveToSuperclass(); } return getMethodsAndRelease(findState); } private void findUsingReflectionInSingleClass(FindState findState) { Method[] methods; try { // 拿到该类中的所有方法，不包括父类的方法 methods = findState.clazz.getDeclaredMethods(); } catch (Throwable th) { try { // 拿到该类中的所有方法，包括父类的方法 methods = findState.clazz.getMethods(); } catch (LinkageError error) { ...... } findState.skipSuperClasses = true; } // 遍历所有方法，找到符合目标的订阅方法 for (Method method : methods) { int modifiers = method.getModifiers(); // 校验方法的权限，只能是 public 的 if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { Class<?>[] parameterTypes = method.getParameterTypes(); // 并且该方法的参数只能为一个 if (parameterTypes.length == 1) { // 拿到该方法的 Subscribe 注解属性，如果没有则不是订阅方法 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)) { ...... } } } }到这里，注册的流程基本上就完了。上面的注释写的基本上很详细了，也是从上到下的一个流程。
注册完成后，就是接受订阅事件了，以发布事件为入口，看看事件发布后，订阅的方法是如何接受到发布的订阅事件。
public class EventBus { public void post(Object event) { //用于判断在当前线程的分发状态 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 void postSingleEvent(Object event, PostingThreadState postingState) throws Error { ...... postSingleEventForEventType(event, postingState, eventClass); ...... } private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) { CopyOnWriteArrayList<Subscription> subscriptions; synchronized (this) { // 根据事件的类型，拿到所有订阅该事件的方法 subscriptions = subscriptionsByEventType.get(eventClass); } if (subscriptions != null && !subscriptions.isEmpty()) { for (Subscription subscription : subscriptions) { ...... // 遍历所有订阅该事件的方法，并进行分发 postToSubscription(subscription, event, postingState.isMainThread); ...... } return true; } return false; } private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) { ...... // 这里会进行相应的线程切换，就不做过多解析 invokeSubscriber(subscription, event) ...... } void invokeSubscriber(Subscription subscription, Object event) { try { //使用反射进行相应事件的调用 subscription.subscriberMethod.method.invoke(subscription.subscriber, event); } catch (InvocationTargetException e) { handleSubscriberException(subscription, event, e.getCause()); } catch (IllegalAccessException e) { throw new IllegalStateException("Unexpected exception", e); } } }发布事件到这就结束了，就是从订阅的集合中拿到订阅的相关方法并进行调用，就完事了。
最后就是解注册了，相比分发就更为简单了，没什么说的，就是从集合中找出，删除完事。
public class EventBus { public synchronized void unregister(Object subscriber) { // 拿到解注册类中订阅的所有方法 List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber); if (subscribedTypes != null) { for (Class<?> eventType : subscribedTypes) { // 遍历所有方法，根据事件类型，从 subscriptionsByEventType 集合中移除相应的订阅事件 unsubscribeByEventType(subscriber, eventType); } // 移除 typesBySubscriber.remove(subscriber); } else { logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass()); } } private void unsubscribeByEventType(Object subscriber, Class<?> eventType) { List<Subscription> subscriptions = subscriptionsByEventType.get(eventType); if (subscriptions != null) { int size = subscriptions.size(); for (int i = 0; i < size; i++) { Subscription subscription = subscriptions.get(i); if (subscription.subscriber == subscriber) { subscription.active = false; subscriptions.remove(i); i--; size--; } } } } }以上就是我们正常使用 EventBus 的全过程解析了，有没有豁然开朗。其实原理并没有多么深奥，只要静下心看看就可以理解。更多需要注意的就是那些异常的处理以及细节的考虑了，这些才是这个项目的精华所在。
既然题目是高效使用，那这部分才是要说的重点了，上面哪些相信大家都已经耳熟能详了，主要是总结一下。
在介绍使用之前，先看看一组数据对比，根据官方作者自述，这种方式可以进一步提升 app 的运行效率。因为在其编译时期就为其建立了一份索引库，而不是在运行时才去建立。相当于一种空间换时间，来提高 app 的运行效率
下面来看看怎么使用
1、在项目根目录中的 build 文件中新增 android-apt 插件引用
dependencies { classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' }2、在项目的 build 文件中使用插件
apply plugin: 'kotlin-kapt' kapt { arguments { arg('eventBusIndex', 'com.silence.eventbusdemo.EventBusIndex') } } dependencies { implementation 'org.greenrobot:eventbus:3.2.0' kapt 'org.greenrobot:eventbus-annotation-processor:3.0.1' }配置完成后点击 Build -> Rebuild Project 。重新 build 项目后，会在 build/generated/source/kapt/debug/com/silence/eventbusdemo 目录下生成一个 EventBusIndex 类。
这个类比较简单。就是在编译期间找到所有的订阅方法，然后构造相关订阅方法的信息，保存起来。在进行事件发布时，直接从这里面找就可以了。
public class EventBusIndex implements SubscriberInfoIndex { private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX; static { SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>(); putIndex(new SimpleSubscriberInfo(MainActivity.class, true, new SubscriberMethodInfo[] { new SubscriberMethodInfo("dataReceive", DataModel.class, ThreadMode.MAIN, 2, true), })); } private static void putIndex(SubscriberInfo info) { SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info); } @Override public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) { SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass); if (info != null) { return info; } else { return null; } } }3、在 Application 中引用生成的类
//别忘了在 manifest 文件中声明 aplication class DemoApplication: Application() { override fun onCreate() { super.onCreate() EventBus.builder().addIndex(EventBusIndex()).installDefaultEventBus() } }4、使用和普通的正常使用一样，这里就不赘述了
还记得上面跳过的那个获取订阅事件方法吗，有一处没有分析，这里就分析一下。
class SubscriberMethodFinder { List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) { if (ignoreGeneratedIndex) { //使用反射寻找，由于没有进行任何相关配置，所以默认会使用反射进行查找，所以效率相对来说比较底下 subscriberMethods = findUsingReflection(subscriberClass); } else { //使用添加的信息寻找，相关配置完成后会走到这里 subscriberMethods = findUsingInfo(subscriberClass); } } private List<SubscriberMethod> findUsingInfo(Class<?> 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); } private SubscriberInfo getSubscriberInfo(FindState findState) { ...... for (SubscriberInfoIndex index : subscriberInfoIndexes) { // 根据订阅类，从编译时生成的集合中找出订阅方法的信息 SubscriberInfo info = index.getSubscriberInfo(findState.clazz); if (info != null) { return info; } } ...... return null; } }到这，普通版和进化版就介绍完毕了。有兴趣的同学可以看看那个插件是怎么生成相关类的，这里就不贴了，官网源码上就有。
为了加深印象，这里 100 多行手撸了一个 简易版 CustomEventBus。仅供学习，不能再项目中使用昂。
这里在附上 CustomeEventBus 源码。
