主要的使用步骤就是例如以下4步，点击此链接查看样例及介绍。

  1. 定义事件类型：
    `public class MyEvent {}`
  2. 定义事件处理方法：
    `public void onEventMainThread`
  3. 注冊订阅者：
    `EventBus.getDefault().register(this)`
  4. 发送事件：
    `EventBus.getDefault().post(new MyEvent())`
一.实现

**EventBus**用法非常easy，但用一个东西，假设不了解它的实现用起来心里总是没底，万一出问题咋办都不知道，所以还是研究一下它的实现，肯定要Read the fucking Code。事实上主要是`EventBus`这一个类。在看看Code时须要了解几个概念与成员，了解了这些后实现就非常好理解了。

  • EventType：onEvent\*函数中的參数，表示事件的类型
  • Subscriber：订阅源，即调用register注冊的对象。这个对象内包括onEvent\*函数
  • SubscribMethod：`Subscriber`内某一特定的onEvent\*方法，内部成员包括一个`Method`类型的method成员表示这个onEvent\*方法，一个`ThreadMode`成员threadMode表示事件的处理线程。一个`Class<?>`类型的eventType成员表示事件的类型`EventType`。

     

     

  • Subscription，表示一个订阅对象，包括订阅源`Subscriber`。订阅源中的某一特定方法`SubscribMethod`，这个订阅的优先级`priopity`


了解了以上几个概念后就能够看`EventBus`中的几个重要成员了

 
 // EventType -> List<Subscription>。事件到订阅对象之间的映射
   privatefinal Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

  // Subscriber -> List<EventType>，订阅源到它订阅的的全部事件类型的映射
  privatefinal Map<Object, List<Class<?>>> typesBySubscriber;

   // stickEvent事件。后面会看到
  privatefinal Map<Class<?>, Object> stickyEvents;

  // EventType -> List<?

 

extends EventType>。事件到它的父事件列表的映射。即缓存一个类的全部父类 privatestaticfinal Map<Class<?>, List<Class<?

>>> eventTypesCache = new HashMap<Class<?

>, List<Class<?

>>>();

 

二. 注冊事件：Register

通过`EventBus.getDefault().register`方法能够向`EventBus`注冊来订阅事件，`register`有非常多种重载形式，但大都被标记为`Deprecated`了，所以还是不用为好，前面说了事件处理方法都是以*onEvent*开头，事实上是能够通过register方法改动的，但对应的方法被废弃了，还是不要用了，就用默认的*onEvent*。除下废弃的register方法。还有下面4个**public**的`register`方法

publicvoid register(Object subscriber) {
    register(subscriber, defaultMethodName, false, 0);
}

publicvoid register(Object subscriber, int priority) {
    register(subscriber, defaultMethodName, false, priority);
}

publicvoid registerSticky(Object subscriber) {
    register(subscriber, defaultMethodName, true, 0);
}

publicvoid registerSticky(Object subscriber, int priority) {
    register(subscriber, defaultMethodName, true, priority);
}

能够看到，这4个方法都调用了同一个方法：

privatesynchronizedvoid register(Object subscriber, String methodName, boolean sticky, int priority) {
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass(),
methodName);
    for (SubscriberMethod subscriberMethod : subscriberMethods) {
        subscribe(subscriber, subscriberMethod, sticky, priority);
    }
}
由此可见：

第一个參数就是订阅源。第二个參数就是用到指定方法名约定的，默觉得*onEvent*开头，说默认是事实上是能够通过參数改动的，但前面说了，方法已被废弃。最好不要用。第三个參数表示是否是*Sticky Event*，第4个參数是优先级，这两个后面再说。

 

在上面这种方法中，使用了一个叫`SubscriberMethodFinder`的类，通过其`findSubscriberMethods`方法找到了一个`SubscriberMethod`列表，前面知道了`SubscriberMethod`表示Subcriber内一个onEvent\*方法。能够看出来`SubscriberMethodFinder`类的作用是在Subscriber中找到全部以methodName（即默认的onEvent）开头的方法，每一个找到的方法被表示为一个`SubscriberMethod`对象。

`SubscriberMethodFinder`就不再分析了，但有两点须要知道：

  1. 全部事件处理方法**必需是`public void`类型**的，而且仅仅有一个參数表示*EventType*。
  2. `findSubscriberMethods`不仅仅查找*Subscriber*内的事件处理方法，**同一时候还会查到它的继承体系中的全部基类中的事件处理方法**。

找到*Subscriber*中的全部事件处理方法后，会对每一个找到的方法（表示为`SubscriberMethod`对象）调用`subscribe`方法注冊。`subscribe`方法干了三件事：

  1. 依据`SubscriberMethod`中的*EventType*类型将`Subscribtion`对象存放在`subscriptionsByEventType`中。建立*EventType*到*Subscription*的映射，每一个事件能够有多个订阅者。

     

     

  2. 依据`Subscriber`将`EventType`存放在`typesBySubscriber`中，建立*Subscriber*到*EventType*的映射，每一个Subscriber能够订阅多个事件。
  3. 假设是*Sticky*类型的订阅者。直接向它发送上个保存的事件（假设有的话）。

通过*Subscriber*到*EventType*的映射，我们就能够非常方便地使一个Subscriber取消接收事件，通过*EventType*到*Sucscribtion*的映射，能够方便地将对应的事件发送到它的每个订阅者。

 

接下来是对每一个事件的详细分析。