Android EventBus源码学习

本文主要是介绍Android EventBus源码学习，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1、Register(注册过程)

会调用private synchronized voidregister(Object subscriber, boolean sticky, int priority)
其中Object subscriber是注册代码所在函数的对象，就是消息的订阅者（subscriber），sticky指是否是粘性，priority是指订阅的优先级，这个函数的源码是：

List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());
for (SubscriberMethod subscriberMethod : subscriberMethods) {subscribe(subscriber, subscriberMethod, sticky, priority);
}

这个方法详细解释:

(1)SubscriberMethod：这个类封装了三个对象,分别是:

final Method method

java里面的Method类，这个对象方便发送消息之后，调用invoke执行接收消息函数

final ThreadMode threadMode，定义接收到返回的数据所在的线程，有四种情况：

PostThread
订阅者和消息发送者在同一个线程，这是默认的一种情况，
当需要处理非常简单的单任务的时候，不依赖在主线程里面，建议使用这种模式
MainThread
订阅者在主线程，即UI线程
BackgroundThread
后台线程，订阅者在后台线程
Async
异步线程，在订阅者方法里面实现耗时操作可以使用这种模式，应该避免大数量长时间的使用异步线程来处理消息，因为EventBus使用缓存线程池高效的回收利用线程完成处理的消息

final Class<?> eventType

订阅消息方法的参数类型(这个类型可以是基本类型，也可以是自己封装的类型)

(2) SubscriberMethodFinder

这个类主要用来查找消息订阅者函数

(3) findSubscriberMethods

查找注册消息订阅类的接收消息的函数，详解如下：

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {String key = subscriberClass.getName();//获取注册类的名字，作为map的keyList<SubscriberMethod> subscriberMethods; //用于存储找到的订阅函数synchronized (methodCache) {subscriberMethods = methodCache.get(key);//首先查找是否在map里存在订阅函数}if (subscriberMethods != null) {return subscriberMethods;//如果在map里面找到了订阅函数就返回}subscriberMethods = new ArrayList<SubscriberMethod>();Class<?> clazz = subscriberClass;HashSet<String> eventTypesFound = new HashSet<String>();StringBuilder methodKeyBuilder = new StringBuilder();while (clazz != null) {String name = clazz.getName();if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {// Skip system classes, this just degrades performance 表明不支持系统的类break;}// Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)Method[] methods = clazz.getDeclaredMethods();//获取注册所在类定义的函数for (Method method : methods) {//遍历函数查找订阅消息的函数String methodName = method.getName();//获取函数名//判断函数是否是以”onEvent开头”，此处说明定义消息订阅函数的时候要以”onEvent”开头if (methodName.startsWith(ON_EVENT_METHOD_NAME)) {int modifiers = method.getModifiers(); //获取订阅函数的修饰符(public,private,protected)//订阅者必须是public修饰的if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {Class<?>[] parameterTypes = method.getParameterTypes(); //获取订阅函数的参数类型if (parameterTypes.length == 1) {//只有一个参数</span>//获取除”onEvent”之外的字符，用于判断线程类型String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.length());ThreadMode threadMode;//如果订阅函数的名字是”onEvent”,那么默认是PostThread类型if (modifierString.length() == 0) { threadMode = ThreadMode.PostThread;} else if (modifierString.equals("MainThread")) {//如果订阅函数的名字是”onEventMainThread”,那么是MainThread类型threadMode = ThreadMode.MainThread; } else if (modifierString.equals("BackgroundThread")) { //如果订阅函数的名字是”onEventBackgroundThread”，那么是BackgroundThread类型threadMode = ThreadMode.BackgroundThread; } else if (modifierString.equals("Async")) {//如果订阅函数的名字是”onEventAsync”,那么是Async类型threadMode = ThreadMode.Async; } else {//特殊情况继续if (skipMethodVerificationForClasses.containsKey(clazz)) {continue;} else {//否则注册消息不合法throw new EventBusException("Illegal onEvent method, check for typos: " + method);}}Class<?> eventType = parameterTypes[0];methodKeyBuilder.setLength(0);methodKeyBuilder.append(methodName);methodKeyBuilder.append('>').append(eventType.getName());//将订阅函数，订阅函数的类型放到StringBuffer里面String methodKey = methodKeyBuilder.toString();//Haset的值唯一性，如果之前存在就不添加到订阅集合里面去if (eventTypesFound.add(methodKey)) { // Only add if not already found in a sub class// SubscriberMethod封装了Method方法，订阅函数所处的线程，订阅函数参数类型的名字             subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType)); } }} else if (!skipMethodVerificationForClasses.containsKey(clazz)) { Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + clazz + "." + methodName); }} } clazz = clazz.getSuperclass(); }//为空，表明没有在注册的类里面找到订阅消息的函数，抛出没有找到用public修饰的订阅函数if (subscriberMethods.isEmpty()) { throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called " + ON_EVENT_METHOD_NAME); }else {//在map容器里面添加订阅<key=注册函数所属的类，value=List<SubscriberMethod>>synchronized (methodCache) { methodCache.put(key, subscriberMethods); } return subscriberMethods; }}
}

接下来是真正的消息订阅的过程：

//这个函数只能在同步代码块中执行，因为可能有多个函数注册为订阅者
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {//获得订阅函数参数的类型Class<?> eventType = subscriberMethod.eventType;//获取订阅属性CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); //封装订阅者，订阅方法，优先级Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority);if (subscriptions == null) {//新建一个subscriptions = new CopyOnWriteArrayList<Subscription>();subscriptionsByEventType.put(eventType, subscriptions);} else {if (subscriptions.contains(newSubscription)) {throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " + eventType);}}// Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)// subscriberMethod.method.setAccessible(true);int size = subscriptions.size();for (int i = 0; i <= size; i++) {if (i == size || newSubscription.priority > subscriptions.get(i).priority) {subscriptions.add(i, newSubscription);//添加一个订阅者break;}}List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);if (subscribedEvents == null) {subscribedEvents = new ArrayList<Class<?>>();//key=订阅者所属的类，value=订阅函数参数类型名，这里添加是为了到时注销订阅typesBySubscriber.put(subscriber, subscribedEvents);}//添加订阅函数参数属性名subscribedEvents.add(eventType); if (sticky) {//是否是粘性注册if (eventInheritance) {//默认为true// 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>).//如果是postSticky的话，stickyEvents这里会有值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();//这里实际上直接invoke这个stickyEvent方法了checkPostStickyEventToSubscription(newSubscription, stickyEvent);}}} else {Object stickyEvent = stickyEvents.get(eventType);checkPostStickyEventToSubscription(newSubscription, stickyEvent);}}
}

2、Post(发送消息)

接下来看消息发送过程，开始函数是post(),如果是postSticky(),代码如下：

//粘性发送消息，最近的粘性消息会被保存在内存当中，被之后调用，当然注册的时候使用registerSticky(Object)
public void postSticky(Object event) {synchronized (stickyEvents) {stickyEvents.put(event.getClass(), event);}// Should be posted after it is putted, in case the subscriber wants to remove immediatelypost(event);//最后会调用post函数
}

接下来分析Post函数：

public void post(Object event) {//获取post线程状态的初始值(ThreadLocal)PostingThreadState postingState = currentPostingThreadState.get();List<Object> eventQueue = postingState.eventQueue;//post队列eventQueue.add(event);//添加当前消息if (!postingState.isPosting) {//消息还没有被发出去//是否是主线程的消息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;}}
}

接下来分析postSingleEvent函数：

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {//获取消息所属函数名(“start” = String)Class<?> eventClass = event.getClass();boolean subscriptionFound = false;//是否找到订阅者if (eventInheritance) {//默认为true//查找发送消息类型相关的类型，例如public final class String implements Serializable, Comparable<String>//此时List里面有String , Serializable , Comparable , CharSequence , ObjectList<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));}}}
}

接下来分析lookupAllEventTypes()函数:

private List<Class<?>> lookupAllEventTypes(Class<?> eventClass) {synchronized (eventTypesCache) {List<Class<?>> eventTypes = eventTypesCache.get(eventClass);//获取消息类型相关的类型if (eventTypes == null) {eventTypes = new ArrayList<Class<?>>();Class<?> clazz = eventClass;while (clazz != null) {eventTypes.add(clazz);//添加这个class本身addInterfaces(eventTypes, clazz.getInterfaces());//添加这个class完成的interfaceclazz = clazz.getSuperclass();//添加这个class所属的父类}eventTypesCache.put(eventClass, eventTypes);}return eventTypes;}
}

接下来分析postSingleEventForEventType()函数:

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) {postingState.event = event;postingState.subscription = subscription;boolean aborted = false;try { //把消息发送给订阅者postToSubscription(subscription, event, postingState.isMainThread); aborted = postingState.canceled;} finally {postingState.event = null;postingState.subscription = null;postingState.canceled = false;}if (aborted) {break;}}return true;}return false;
}

接下来分析postToSubscription()函数:

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {//根据消息订阅者所在的线程调用switch (subscription.subscriberMethod.threadMode) {case PostThread:invokeSubscriber(subscription, event);//默认情况直接调用break;case MainThread:if (isMainThread) {invokeSubscriber(subscription, event);//如果在UI线程就直接调用} else {//不在UI线程，通过handler方式发送消息(在UI线程中定义非ui线程订阅函数)mainThreadPoster.enqueue(subscription, event);}break;case BackgroundThread:if (isMainThread) {// UI线程，在线程池(EventBus类中的Executors.newCachedThreadPool)发送消息(在后台线程中定义ui线程订阅函数)backgroundPoster.enqueue(subscription, event);} else {//在后台线程发送消息invokeSubscriber(subscription, event); }break;case Async:// 在线程池(EventBus类中的Executors.newCachedThreadPool)发送消息asyncPoster.enqueue(subscription, event);break;default:throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);}
}

3、UnRegister(注销)

注销订阅，主要在函数unregister()中体现：

public synchronized void unregister(Object subscriber) {//获取所有注册函数的参数类型<key=注册所在的类,value=类里面注册函数参数的类型>List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);       if (subscribedTypes != null) {for (Class<?> eventType : subscribedTypes) {unubscribeByEventType(subscriber, eventType);//根据参数类型，逐一注销}typesBySubscriber.remove(subscriber);//移除注册类} else {Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());}
}

接下来分析unubscribeByEventType()函数:

private void unubscribeByEventType(Object subscriber, Class<?> eventType) {//获取封装了订阅函数的容器List<Subscription> subscriptions = subscriptionsByEventType.get(eventType); if (subscriptions != null) {int size = subscriptions.size();for (int i = 0; i < size; i++) {//对于封装的Subscriber和Method等逐一移除Subscription subscription = subscriptions.get(i);if (subscription.subscriber == subscriber) {subscription.active = false;subscriptions.remove(i);i--;size--;}}}
}