Android开发事件总线之EventBus运用和框架原理深入理解

　　在我们的android项目开发过程中，经常会有各个组件如activity,fragment和service之间，各个线程之间的通信需求；项目中用的最多的是Android框架的广播机制，android的广播机制是基于系统的Binder机制实现IPC或者进程内部的通信，而Binder这种IPC机制相比于Linux原有的机制来说具有，性能更好、安全性更高和易用性更好的特点，所以android系统中很多系统事件都是基于广播的方式来发送，如开机广播、电量低的提醒广播等。然而在一个android的进程内部，各个组件、子线程之间通信如果使用广播的话，那就有种杀鸡用牛刀的赶脚。。。

[Android]进程内部通信之EventBus

　　EventBus是greenrobot开发的发布/订阅事件总线组件，也是基于观察者模式，不同点在于，EventBus框架解耦了事件的发送和订阅模块，事件对象的分发交由EventBus来处理，下面的框架图可以清晰的看到这一点。

[Android]EventBus 3.0基本使用方法

一、定义事件类

作为事件的发布者，需要定义所发布的事件的类：

public class MessageEvent {
    private String msg;
    public MessageEvent(String msg) {
    this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

二、注册/取消注册响应事件

作为事件的订阅者，需要把响应事件的对象注册到EventBus当中:

EventBus.getDefault().register(obj)

当不需要处理某个类型的事件的时候，取消对这个事件的监听:

EventBus.getDefault().unregister(obj)

三、声明和注释订阅方法，选择指定线程模式

　　作为事件的订阅者，需要定义事件的响应方法，方法名称可以随意取，方法的形参类型，必须和监听的事件对象类型一致：

@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(this, event.getMsg (),
    Toast.LENGTH_SHORT).show();
}

3.1 四种线程模式

事件订阅者可以通过注解的方式选择处理事件的方法所在的线程：

PostThread：如果事件处理函数指定了线程模型为PostThread，那么事件的发布和接收处理会在同一个线程当中。

BackgroundThread：如果事件处理函数指定了线程模型为BackgroundThread，那么如果事件是在UI线程中发布出来的，那么该事件处理函数就会在新的子线程中运行，如果事件发布本来就是非UI线程中发布出来 的，那么该事件处理函数直接在发布事件的线程中执行。

MainThread:如果事件处理函数指定了线程模型为MainThread，那么不论事件对象是在哪个线程中发布出来的，该事件处理函数都会在UI线程中执行。

Async：如果事件处理函数指定了线程模型为Async，那么无论事件在哪个线程发布，该事件处理函数都会在新建的子线程中执行。

3.2 黏性事件

通过注解的方式设置sticky为true，那么事件处理函数则可以处理上一次的事件对象：

@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)

四、EventBus 3.0源码详解

4.1 注册流程　

/**
* Registers the given subscriber to receive events.     Subscribers must call {@link #unregister(Object)} once they
* are no longer interested in receiving events.
* <p/>
* Subscribers have event handling methods that must be  annotated by {@link Subscribe}.
* The {@link Subscribe} annotation also allows configuration    like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {
//通过注册的对象得到其类的class对象
Class<?> subscriberClass = subscriber.getClass();
//通过类的class对象得到此对象的订阅方法列表
List<SubscriberMethod> subscriberMethods =  subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod :subscriberMethods) {
            //线程同步，遍历订阅方法列表，注册每一个订阅方法
            subscribe(subscriber, subscriberMethod);
        }
    }
}

代码subscriberMethodFinder.findSubscriberMethods(subscriberClass)获取订阅方法列表具体如下：

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //在缓存中查找此class对象对应的订阅方法列表
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
      return subscriberMethods;
    }
  //是否忽略注解器生成的MyEventBusIndex类
  if (ignoreGeneratedIndex) {
        //通过反射机制得到订阅者类class对象对应的订阅事件方法列表
        subscriberMethods = findUsingReflection(subscriberClass);
  } else {
        //从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法列表
        subscriberMethods = findUsingInfo(subscriberClass);
    }
  if (subscriberMethods.isEmpty()) {
      throw new EventBusException("Subscriber " + subscriberClass
              + " and its super classes have no public methods with the @Subscribe annotation");
  } else {
      //缓存此class对象的订阅方法列表
      METHOD_CACHE.put(subscriberClass, subscriberMethods);
      return subscriberMethods;
  }
}

通过反射机制获取订阅方法列表：

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
  FindState findState = prepareFindState();
  findState.initForSubscriber(subscriberClass);
  while (findState.clazz != null) {
      //遍历当前class对象和其父类中的订阅方法
      findUsingReflectionInSingleClass(findState);
      findState.moveToSuperclass();
  }
  return getMethodsAndRelease(findState);
}

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, see https://github.com/greenrobot/EventBus/issues/149
    methods = findState.clazz.getMethods();
    findState.skipSuperClasses = true;
    }
    //遍历此类的方法
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        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)) {
            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");
        }
    }
}

至此，我们得到了所有的订阅函数列表，下一步，会对每一个订阅函数进行注册：

// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    //通过监听的事件对象得到其对应的监听者对象列表
    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) {
        if (eventInheritance) {
        // Existing sticky events of all subclasses of eventType have to be considered.
        // Note: Iterating over all events may be inefficient with lots of sticky events,
        // thus data structure should be changed to allow a more efficient lookup
        // (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
        Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
        for (Map.Entry<Class<?>, 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);
    }
}

事件的注册流程实际是从监听者对象和消息事件两个维度，将对方分别添加到自己对应的列表当中，具体可以通过以下流程图总结：

4.2发布流程

/** Posts the given event to the event bus. */
public void post(Object event) {
    //通过ThreadLocal机制得到当前线程的postingState对象
    PostingThreadState postingState = currentPostingThreadState.get();
    List<Object> eventQueue = postingState.eventQueue;
    //在此线程的eventQueue中添加此事件对象
    eventQueue.add(event);
    if (!postingState.isPosting) {
        //判断当前线程是否UI线程
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        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;
        }
    }
}

ThreadLocal机制可以存储各个线程的局部数据；
postSingleEvent函数处理此线程消息队列中的消息事件：

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
    if (eventInheritance) {
        //得到此事件类的所有父类和接口
        List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
        int countTypes = eventTypes.size();
        for (int h = 0; h < countTypes; h++) {
            Class<?> clazz = eventTypes.get(h);
            //通过事件类得到其对应的订阅者对象列表，将事件对象分发到相应的订阅函数中处理，至此实现了事件消息的传递
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
    } else {
        //通过事件类得到其对应的订阅者对象列表，将事件对象分发到相应的订阅函数中处理，至此实现了事件消息的传递
        subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
   }
    if (!subscriptionFound) {
        if (logNoSubscriberMessages) {
        Log.d(TAG, "No subscribers registered for event " + eventClass);
        }
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
            eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

事件消息对象具体的分发函数：postToSubscription

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    //根据注解方式设置的线程模式，在不同的线程中执行订阅函数
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case BACKGROUND:
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

至此，我们完成了事件消息对象的分发流程，以下流程图来总结post的过程：

4.3 取消注册流程

/** Unregisters the given subscriber from all event classes. */
public synchronized void unregister(Object subscriber) {
    //根据订阅者对象得到其对应的事件类型列表
    List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        for (Class<?> eventType : subscribedTypes) {
            //遍历事件类型列表，得到每个事件类型对应的订阅者对象列表，遍历这个列表，如果是此观察者对象，则从列表中删除
            unsubscribeByEventType(subscriber, eventType);
        }
        //typesBySubscriber中删除此订阅者对象
        typesBySubscriber.remove(subscriber);
    } else {
        Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

unsubscribeByEventType函数：

/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
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--;
            }
        }
    }
}

取消注册的流程总结如下：

1.通过观察者类对象通过MAP表得到其对应的事件类class对象列表.

2.遍历list列表，通过事件类class对象得到其在MAP表中对应的观察者类对象列表。

3.遍历此观察者对象列表，判断如果列表中存在需要取消的注册观察者对象，则从对象列表中删除此观察者对象。

4.从第1步中得到的MAP对象中删除以取消注册的观察者对象为key的映射项目。

5.完成unregister过程。

五、相似功能框架的比较

和EventBus具有相似功能的组件有Square推出的Otto,Android系统的LocalBroadCast,共同点是这三个框架都是进程内通信，方便进程内各个组件和子线程间的通信。

Ottootto采用了注解的方式完成注册，Otto更多使用场景应该就是在主线程中，因为其不像EventBus可以选择不同的线程模式。

LocalBroadCast是Android在Android Support Library中提供的，用于进程内部通信框架，其主要目的是保证广播在进程内部传递，确保通讯的安全行，其内部通过handler的方式实现。

下载说明