一篇帶給你EventBus原理解析
作者：Android開發(fā)編程
EventBus基于觀察者模式，原理是大體也是將觀察者與要觀察的消息注冊到一個Map，當(dāng)有消息發(fā)布時，從Map中找到觀察者，并調(diào)用觀察者對應(yīng)的方法，下面我們基于源碼進(jìn)行解析來看看是不是這樣的原理。
EventBus基于觀察者模式，原理是大體也是將觀察者與要觀察的消息注冊到一個map，當(dāng)有消息發(fā)布時，從map中找到觀察者，并調(diào)用觀察者對應(yīng)的方法，下面我們基于源碼進(jìn)行解析來看看是不是這樣的原理
不廢話，沒有賣課，直接來
1、EventBus訂閱
（1）訂閱整體流程
EventBus的定義始于register方法：
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);
}
}
}
register方法主要是從訂閱者class對象中找出所有訂閱消息的方法列表，然后對每個訂閱方法調(diào)用subscribe進(jìn)行訂閱：
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
//方法訂閱的消息類型，即訂閱方法的參數(shù)類型class
Class<?> eventType = subscriberMethod.eventType;
//創(chuàng)建訂閱者/觀察者
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//從事件/訂閱者map中，找出訂閱事件的訂閱者列表
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
//事件/訂閱者map中沒有事件相關(guān)的訂閱者，則：
//新建訂閱事件的訂閱者列表
subscriptions = new CopyOnWriteArrayList<>();
//并將事件的class作為key，事件訂閱者列表作為value存入事件/訂閱者map
subscriptionsByEventType.put(eventType, subscriptions);
} else {
//
if (subscriptions.contains(newSubscription)) {
//已經(jīng)訂閱過，則拋出異常
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) {
//按優(yōu)先級將訂閱者加入對應(yīng)的位置
subscriptions.add(i, newSubscription);
break;
}
}
//訂閱者/事件map中找到訂閱事件列表
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
//如果訂閱者/事件map沒有訂閱事件列表，則:
//新建訂閱事件列表，并存入訂閱者/事件map中，key是訂閱者，value是要訂閱的事件列表
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {
//如果訂閱事件是粘性事件，則：
if (eventInheritance) {
//事件允許發(fā)布到其父類或者父接口，則：
// 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) {
//遍歷粘性事件map
Class<?> candidateEventType = entry.getKey();
if (eventType.isAssignableFrom(candidateEventType)) {
//事件是粘性事件的父類、父接口，則：
Object stickyEvent = entry.getValue();
//發(fā)布粘性事件
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
//發(fā)布粘性事件
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
- subscribe訂閱事件主要是將訂閱者與要訂閱的事件存入事件/訂閱者map中，等待發(fā)布消息時從map中找到訂閱者并調(diào)用對應(yīng)的訂閱方法消耗處理事件。
- subscribe訂閱時有兩個map，一個是subscriptionsByEventType（事件/訂閱者map，key是事件，value是訂閱者列表），一個是typesBySubscriber（訂閱者/事件列表map，key是訂閱者，value是要訂閱的事件列表），subscriptionsByEventType用于發(fā)布消息時從map中快速找到訂閱者列表并調(diào)用相應(yīng)的訂閱方法，typesBySubscriber用于取消訂閱時，從map中快速找到事件列表，根據(jù)此事件列表快速從subscriptionsByEventType取消訂閱。
- 訂閱消息時確實也是將訂閱者與定要訂閱的事件存入事件/訂閱者map中。
register方法中的subscriberMethodFinder.findSubscriberMethods(subscriberClass)，它從訂閱者class對象中找到要所有要訂閱的事件，我們看看它是怎么實現(xiàn)的：
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//從緩存中獲取訂閱者的所有事件方法列表
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//緩存匯總沒有，則：
if (ignoreGeneratedIndex) {
//如果忽略從編譯器期自動生成訂閱者/事件關(guān)系文件中查找，則：
//通過反射訂閱者class找到訂閱事件方法列表
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//如果從編譯器期自動生成訂閱者/事件關(guān)系文件中查找，則：
//從訂閱者/事件關(guān)系文件中查找訂閱事件方法列表
subscriberMethods = findUsingInfo(subscriberClass);
}
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
//將訂閱者的訂閱事件列表進(jìn)行緩存
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
- findSubscriberMethods有兩個策略。
- 一是通過反射訂閱者class對象找到所有的訂閱事件方法列表。
- 一是從編譯期自動生成的訂閱者/事件關(guān)系文件中查找，默認(rèn)是從訂閱者/事件關(guān)系文件中查找。
（2）反射查找訂閱事件方法列表
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
//從查找狀態(tài)對象復(fù)用池中獲取/創(chuàng)建一個新的查找狀態(tài)對象
FindState findState = prepareFindState();
//初始化查找狀態(tài)對象，設(shè)置訂閱者class
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//通過反射查找查找狀態(tài)對象當(dāng)前class，最開始從訂閱者class開始查找，接著遞歸其父類或者父接口查找
findUsingReflectionInSingleClass(findState);
//繼續(xù)從其父類/父接口中查找
findState.moveToSuperclass();
}
//返回訂閱事件方法列表，并將查找狀態(tài)對象緩存到復(fù)用池中
return getMethodsAndRelease(findState);
}
- findUsingReflection會從當(dāng)前訂閱者的class開始查找所有的訂閱事件方法列表；
- 接著遞歸其父類或者父接口繼續(xù)查找，真正查找一個class的訂閱事件方法列表是findUsingReflectionInSingleClass方法：
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// This is faster than getMethods, especially when subscribers are fat classes like Activities
//反射獲取當(dāng)前class定義的方法列表
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
//出現(xiàn)異常，則獲取所有方法（包含所有父類/父接口）
methods = findState.clazz.getMethods();
//并標(biāo)記不需要從父類/父接口匯總查找
findState.skipSuperClasses = true;
}
for (Method method : methods) {
//遍歷方法列表
//獲取方法訪問性
int modifiers = method.getModifiers();
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
//方法是public、靜態(tài)、抽象，則：
//反射獲取方法的參數(shù)類型列表
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 1) {
//方法參數(shù)只有一個參數(shù)，則：
//反射獲取方法的Subscribe注解對象
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
//方法被Subscribe注解修飾，則：
//獲取參數(shù)類型class
Class<?> eventType = parameterTypes[0];
if (findState.checkAdd(method, eventType)) {
//獲取事件方法的線程模型
ThreadMode threadMode = subscribeAnnotation.threadMode();
//收集注解信息：線程模型、優(yōu)先級、粘性，創(chuàng)建事件方法，并加入訂閱者的訂閱事件方法列表中
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
//如果方法嚴(yán)格校驗并且被Subscribe注解修飾，則拋出方法參數(shù)多于1個的異常
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)) {
//如果方法嚴(yán)格校驗并且被Subscribe注解修飾，則拋出方法非public、非靜態(tài)、非抽象的異常
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}
findUsingReflectionInSingleClass通過反射從class中獲取方法列表，并按Subscribe注解規(guī)則（規(guī)則是：方法被Subscribe修飾、是public/static/abstract、只有一個參數(shù)）進(jìn)行過濾，找到匹配的事件方法，并加入訂閱事件方法列表
（3）編譯期注解處理器，從編譯期生成的訂閱者/事件關(guān)系文件中查找訂閱方法列表
- 從編譯期生成的訂閱者/事件關(guān)系文件中查找訂閱方法列表，涉及編譯期注解處理器解析注解生成訂閱者/事件方法列表關(guān)系文件，然后運行時從這些文件中根據(jù)訂閱者class直接找到事件方法列表。
- EventBus的編譯期注解處理器是獨立的模塊，依賴使用它可以在編譯期自動解析生成訂閱者/事件方法列表關(guān)系文件，避免運行時通過反射查找事件方法列表的性能開銷.
EventBusAnnotationProcessor 是EventBus的編譯期注解處理器實現(xiàn)類，其核心源碼如下：
//訂閱者/事件方法列表關(guān)系列表
private final ListMap<TypeElement, ExecutableElement> methodsByClass = new ListMap<>();
//被忽略的類
private final Set<TypeElement> classesToSkip = new HashSet<>();
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
Messager messager = processingEnv.getMessager();
try {
//讀取模塊定義的訂閱者/事件索引類名（含包名+類名）
String index = processingEnv.getOptions().get(OPTION_EVENT_BUS_INDEX);
if (index == null) {
messager.printMessage(Diagnostic.Kind.ERROR, "No option " + OPTION_EVENT_BUS_INDEX +
" passed to annotation processor");
return false;
}
verbose = Boolean.parseBoolean(processingEnv.getOptions().get(OPTION_VERBOSE));
int lastPeriod = index.lastIndexOf('.');
//訂閱者/事件索引類包名
String indexPackage = lastPeriod != -1 ? index.substring(0, lastPeriod) : null;
//......
//通過注解收集訂閱者/事件方法列表關(guān)系列表
collectSubscribers(annotations, env, messager);
//根據(jù)訂閱語法規(guī)則，生成忽略被忽略的觀察者列表
checkForSubscribersToSkip(messager, indexPackage);
if (!methodsByClass.isEmpty()) {
//生成訂閱者/事件索引類文件
createInfoIndexFile(index);
} else {
messager.printMessage(Diagnostic.Kind.WARNING, "No @Subscribe annotations found");
}
writerRoundDone = true;
} catch (RuntimeException e) {
// IntelliJ does not handle exceptions nicely, so log and print a message
e.printStackTrace();
messager.printMessage(Diagnostic.Kind.ERROR, "Unexpected error in EventBusAnnotationProcessor: " + e);
}
return true;
}
//通過注解收集訂閱者/事件方法列表關(guān)系列表
private void collectSubscribers(Set<? extends TypeElement> annotations, RoundEnvironment env, Messager messager) {
for (TypeElement annotation : annotations) {
//遍歷注解類型列表
//從注解類型元信息中獲取匹配的注解元信息列表
Set<? extends Element> elements = env.getElementsAnnotatedWith(annotation);
for (Element element : elements) {
//遍歷注解元信息列表
if (element instanceof ExecutableElement) {
//如果是方法元信息，則：
ExecutableElement method = (ExecutableElement) element;
if (checkHasNoErrors(method, messager)) {
//校驗方法元信息，如果方法是public且只有一個參數(shù)，則：
//獲取方法所屬的類類型元信息，此類類型就是對應(yīng)的訂閱者，方法是消耗處理事件
TypeElement classElement = (TypeElement) method.getEnclosingElement();
//將訂閱者/事件方法加入訂閱者/事件方法列表map中，key是訂閱者，value是事件方法列表
methodsByClass.putElement(classElement, method);
}
} else {
messager.printMessage(Diagnostic.Kind.ERROR, "@Subscribe is only valid for methods", element);
}
}
}
}
private void checkForSubscribersToSkip(Messager messager, String myPackage) {
for (TypeElement skipCandidate : methodsByClass.keySet()) {
//遍歷訂閱者/事件方法列表map
//訂閱者class類類型元信息
TypeElement subscriberClass = skipCandidate;
while (subscriberClass != null) {
//循環(huán)：訂閱者class不為空，則：
if (!isVisible(myPackage, subscriberClass)) {
//如果訂閱者class不是public或者與要生成的索引類不是同包，則忽略此訂閱則，將其加入忽略列表
boolean added = classesToSkip.add(skipCandidate);
//.......
break;
}
//取出訂閱者要訂閱的事件方法列表
List<ExecutableElement> methods = methodsByClass.get(subscriberClass);
if (methods != null) {
for (ExecutableElement method : methods) {
//遍歷訂閱的事件方法列表
String skipReason = null;
VariableElement param = method.getParameters().get(0);
TypeMirror typeMirror = getParamTypeMirror(param, messager);
if (!(typeMirror instanceof DeclaredType) ||
!(((DeclaredType) typeMirror).asElement() instanceof TypeElement)) {
//參數(shù)類型無法處理（不是基類性、類/接口類型、數(shù)組類型、類型變量、空類型），則標(biāo)間忽略原因，一般不會出現(xiàn)此情況
skipReason = "event type cannot be processed";
}
if (skipReason == null) {
TypeElement eventTypeElement = (TypeElement) ((DeclaredType) typeMirror).asElement();
if (!isVisible(myPackage, eventTypeElement)) {
//如果參數(shù)類型對應(yīng)索引類不可訪問：如不是public或者不在同包名等，則標(biāo)間忽略原因
skipReason = "event type is not public";
}
}
if (skipReason != null) {
//如果被標(biāo)記被忽略，則：
//加入忽略列表
boolean added = classesToSkip.add(skipCandidate);
//.......
break;
}
}
}
//獲取訂閱類的父類/父接口，繼續(xù)遞歸過濾
subscriberClass = getSuperclass(subscriberClass);
}
}
}
//生成訂閱者/事件方法列表索引類文件
private void createInfoIndexFile(String index) {
BufferedWriter writer = null;
try {
//生成訂閱者/事件方法列表索引類文件，文件為索引類全限定名
JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(index);
int period = index.lastIndexOf('.');
//索引類包名
String myPackage = period > 0 ? index.substring(0, period) : null;
//索引類名
String clazz = index.substring(period + 1);
//創(chuàng)建文件讀寫器
writer = new BufferedWriter(sourceFile.openWriter());
if (myPackage != null) {
//文件寫入類包名
writer.write("package " + myPackage + ";\n\n");
}
//文件寫入引用的類
writer.write("import org.greenrobot.eventbus.meta.SimpleSubscriberInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberMethodInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberInfoIndex;\n\n");
writer.write("import org.greenrobot.eventbus.ThreadMode;\n\n");
writer.write("import java.util.HashMap;\n");
writer.write("import java.util.Map;\n\n");
writer.write("/** This class is generated by EventBus, do not edit. */\n");
//文件寫入定義類并實現(xiàn)SubscriberInfoIndex 接口
writer.write("public class " + clazz + " implements SubscriberInfoIndex {\n");
//文件寫入聲明訂閱者/事件方法列表map，key是訂閱者class，value是SubscriberInfo訂閱信息對象
writer.write(" private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;\n\n");
//文件寫入靜態(tài)塊
writer.write(" static {\n");
//文件寫入創(chuàng)建訂閱者/事件方法列表map
writer.write(" SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();\n\n");
//調(diào)用writeIndexLines完成將訂閱者/事件方法列表寫入map中
writeIndexLines(writer, myPackage);
writer.write(" }\n\n");
//文件寫入putIndex方法，方法用于將訂閱者要訂閱的信息存入map中
writer.write(" private static void putIndex(SubscriberInfo info) {\n");
writer.write(" SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);\n");
writer.write(" }\n\n");
//文件寫入實現(xiàn)SubscriberInfoIndex 接口的getSubscriberInfo方法，方法是根據(jù)訂閱者class從map中取訂閱者信息并返回
writer.write(" @Override\n");
writer.write(" public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {\n");
writer.write(" SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);\n");
writer.write(" if (info != null) {\n");
writer.write(" return info;\n");
writer.write(" } else {\n");
writer.write(" return null;\n");
writer.write(" }\n");
writer.write(" }\n");
writer.write("}\n");
} catch (IOException e) {
throw new RuntimeException("Could not write source for " + index, e);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
//Silent
}
}
}
}
//完成將訂閱者/事件方法列表寫入map中
private void writeIndexLines(BufferedWriter writer, String myPackage) throws IOException {
for (TypeElement subscriberTypeElement : methodsByClass.keySet()) {
//遍歷收集到的訂閱者/事件方法列表
if (classesToSkip.contains(subscriberTypeElement)) {
//訂閱者被忽略
continue;
}
//獲取訂閱者class
String subscriberClass = getClassString(subscriberTypeElement, myPackage);
if (isVisible(myPackage, subscriberTypeElement)) {
//調(diào)用索引類的putIndex方法，創(chuàng)建訂閱信息類SimpleSubscriberInfo，作為參數(shù)，其作用是寫入如下語句：
putIndex(new SimpleSubscriberInfo(subscriberClass, true, SubscriberMethodInfo[]))
writeLine(writer, 2,
"putIndex(new SimpleSubscriberInfo(" + subscriberClass + ".class,",
"true,", "new SubscriberMethodInfo[] {");
List<ExecutableElement> methods = methodsByClass.get(subscriberTypeElement);
writeCreateSubscriberMethods(writer, methods, "new SubscriberMethodInfo", myPackage);
writer.write(" }));\n\n");
} else {
writer.write(" // Subscriber not visible to index: " + subscriberClass + "\n");
}
}
}
//創(chuàng)建SubscriberMethodInfo對象并寫入索引文件
private void writeCreateSubscriberMethods(BufferedWriter writer, List<ExecutableElement> methods,
String callPrefix, String myPackage) throws IOException {
for (ExecutableElement method : methods) {
//遍歷事件方法列表
//獲取方法參數(shù)列表
List<? extends VariableElement> parameters = method.getParameters();
//獲取第一個參數(shù)類型對象
TypeMirror paramType = getParamTypeMirror(parameters.get(0), null);
//參數(shù)類型元對象
TypeElement paramElement = (TypeElement) processingEnv.getTypeUtils().asElement(paramType);
//獲取方法名稱
String methodName = method.getSimpleName().toString();
//獲取參數(shù)類型類型，即事件類型
String eventClass = getClassString(paramElement, myPackage) + ".class";
//獲取方法Subscribe注解對象
Subscribe subscribe = method.getAnnotation(Subscribe.class);
List<String> parts = new ArrayList<>();
//創(chuàng)建SubscriberMethodInfo
parts.add(callPrefix + "(\"" + methodName + "\",");
String lineEnd = "),";
if (subscribe.priority() == 0 && !subscribe.sticky()) {
//如果注解信息中優(yōu)先級為0并且非粘性事件，則
if (subscribe.threadMode() == ThreadMode.POSTING) {
//如果線程模式為POSTING，則：
//創(chuàng)建：new SubscriberMethodInfo(methodName, eventClass)
parts.add(eventClass + lineEnd);
} else {
//線程模式不是POSTING，則：
//創(chuàng)建：new SubscriberMethodInfo(methodName, eventClass, ThreadMode.xxx)
parts.add(eventClass + ",");
parts.add("ThreadMode." + subscribe.threadMode().name() + lineEnd);
}
} else {
//如果注解信息中優(yōu)先級不是0或者是粘性事件，則
//創(chuàng)建：new SubscriberMethodInfo(methodName, eventClass, ThreadMode.xxx, priority, sticky)
parts.add(eventClass + ",");
parts.add("ThreadMode." + subscribe.threadMode().name() + ",");
parts.add(subscribe.priority() + ",");
parts.add(subscribe.sticky() + lineEnd);
}
writeLine(writer, 3, parts.toArray(new String[parts.size()]));
if (verbose) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Indexed @Subscribe at " +
method.getEnclosingElement().getSimpleName() + "." + methodName +
"(" + paramElement.getSimpleName() + ")");
}
}
}
編譯器注解處理器其實做的是跟運行時反射獲取訂閱者class的訂閱事件方法列表有點類似，都是從訂閱者class收集subscribe注解修飾的訂閱事件方法列表。
編譯器注解處理器主要做：
- 收集本模塊中被subscribe注解修飾的方法及其所屬的類，并生成訂閱者/事件方法列表map。
- 一個模塊一個索引類，生成本模塊的索引類。
- 將訂閱者/事件方法列表map寫入索引類中的訂閱者/訂閱信息map中，供運行時根據(jù)訂閱者class快速獲取訂閱信息SubscriberInfo。
（4）從編譯期生成的訂閱者/事件關(guān)系文件中查找訂閱方法列表
從編譯期生成的訂閱者/事件索引類文件中查找訂閱方法列表的入口是findUsingInfo：
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
//從查找狀態(tài)對象復(fù)用池中獲取/創(chuàng)建一個新的查找狀態(tài)對象
FindState findState = prepareFindState();
//初始化查找狀態(tài)對象，設(shè)置訂閱者class
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//從索引類中查找訂閱者對應(yīng)的定義信息對象
findState.subscriberInfo = getSubscriberInfo(findState);
if (findState.subscriberInfo != null) {
//如果訂閱者訂閱的訂閱信息對象不為空，則：
//從訂閱信息對象中獲取訂閱事件方法數(shù)組
SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
for (SubscriberMethod subscriberMethod : array) {
//將數(shù)組轉(zhuǎn)為list
if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
findState.subscriberMethods.add(subscriberMethod);
}
}
} else {
//如果索引類中沒有匹配的，則通過運行時注解反射獲取訂閱事件方法列表
findUsingReflectionInSingleClass(findState);
}
//遞歸從父類/父接口繼續(xù)查找
findState.moveToSuperclass();
}
//返回訂閱事件方法列表
return getMethodsAndRelease(findState);
}findUsingInfo方法先從索引類中找到訂閱者class對應(yīng)的訂閱事件方法列表，如果沒有則轉(zhuǎn)為運行時注解通過反射查找
從索引類中找到訂閱者class對應(yīng)的訂閱信息對象的源碼如下：
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
//訂閱信息對象不為空，且有父級訂閱信息對象，則：
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
//如果訂閱者class與父級訂閱信息對象的class一樣，則返回父級訂閱信息對象
return superclassInfo;
}
}
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
//遍歷所有的索引類，即遍歷所有模塊的索引類（一個模塊一個索引類）
//從索引類訂閱者/訂閱信息map中查找訂閱信息對象
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
//找到則返回
return info;
}
}
}
return null;
}- 從編譯期生成的訂閱者/事件關(guān)系文件中查找訂閱方法列表性能上比運行時注解反射獲取事件方法列表更好。
- 因為少了反射查找，編譯器每個模塊都會生成一個索引文件，該索引文件記錄的是訂閱者/訂閱信息map。
- 查找事件方法列表時時間在索引文件進(jìn)行查找并轉(zhuǎn)換為事件方法列表。
2、EventBus發(fā)布消息
EventBus基于觀察者模式，所以其發(fā)布消息的流程大致為從觀察者列表中找到匹配的觀察者，并將消息傳遞給匹配的觀察者處理。
EventBus是不是這樣的處理邏輯呢，我們來看看其發(fā)布源碼，EventBus的發(fā)布消息入口是post方法：
public void post(Object event) {
//從ThreadLocal獲取當(dāng)前線程的PostingThreadState對象
PostingThreadState postingState = currentPostingThreadState.get();
//發(fā)布消息隊列
List<Object> eventQueue = postingState.eventQueue;
//將消息加入隊列中
eventQueue.add(event);
if (!postingState.isPosting) {
//如果發(fā)布隊列沒有運行，則：
//標(biāo)記發(fā)布狀態(tài)所處的線程是否是主線程
postingState.isMainThread = isMainThread();
//標(biāo)記正在發(fā)布消息
postingState.isPosting = true;
if (postingState.canceled) {
//已取消發(fā)布，則拋出異常
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
while (!eventQueue.isEmpty()) {
//遍歷消息隊列
//每次從隊列刪除首個消息，并進(jìn)行發(fā)布
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}post主要做的是將消息加入隊列中，并遍歷隊列對每個消息進(jìn)行一一發(fā)布，我們繼續(xù)看下postSingleEvent：
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
//如果支持發(fā)布的消息的父級類型消息，則：
//從當(dāng)前消息class找出其所有的父類/父接口類型列表，含本身
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
//遍歷消息類型列表
Class<?> clazz = eventTypes.get(h);
//對每一種消息類型進(jìn)行發(fā)布消息
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
//如果不支持發(fā)布的消息的父級類型消息，則：
//直接發(fā)布當(dāng)前消息
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//......
}postSingleEvent中分為兩種情況，一種支持遍歷當(dāng)前消息的父級類型及本身作為消息，然后按照類型一一發(fā)布消息。
一種僅支持消息本身類型，則直接發(fā)布當(dāng)前消息，我們繼續(xù)往下看postSingleEventForEventType：
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
//根據(jù)消息類型class從消息/訂閱者列表map中找到訂閱此消息的訂閱者列表
subscriptions = subscriptionsByEventType.get(eventClass);
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
//遍歷此消息的訂閱者列表
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
//調(diào)用postToSubscription將消息傳遞給訂閱者進(jìn)行處理
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;
}postSingleEventForEventType中根據(jù)消息類型class從消息/訂閱者列表map中找到訂閱者列表，然后遍歷訂閱者列表，將消息傳遞給每個訂閱者進(jìn)行消息的處理。
我們繼續(xù)往下看postToSubscription：
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
//如果訂閱方法要求線程模式是POSTING，即在當(dāng)前線程進(jìn)行處理，則：
//直接調(diào)用invokeSubscriber方法回調(diào)訂閱者的訂閱方法處理消息
invokeSubscriber(subscription, event);
break;
case MAIN:
//如果訂閱方法要求線程模式是MAIN，即要求在主線程進(jìn)行處理，則：
if (isMainThread) {
//當(dāng)前已是主線程，則直接調(diào)用invokeSubscriber方法回調(diào)訂閱者的訂閱方法處理消息
invokeSubscriber(subscription, event);
} else {
//當(dāng)前不是主線程，則將使用handler轉(zhuǎn)入主線程中處理
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED:
//如果訂閱方法要求線程模式是MAIN_ORDERED，即要求在主線程進(jìn)行串行處理，則：
if (mainThreadPoster != null) {
//如果設(shè)置了主線程handler，則使用handler轉(zhuǎn)入主線程中處理
mainThreadPoster.enqueue(subscription, event);
} else {
// temporary: technically not correct as poster not decoupled from subscriber
//如果沒有設(shè)置主線程handler，則直接在當(dāng)前線程處理
invokeSubscriber(subscription, event);
}
break;
case BACKGROUND:
//如果訂閱方法要求線程模式是BACKGROUND，即要求在子線程進(jìn)行處理，則：
if (isMainThread) {
//當(dāng)前是主線程，則將消息轉(zhuǎn)入子線程進(jìn)行處理
backgroundPoster.enqueue(subscription, event);
} else {
//當(dāng)前已子線程，則直接在當(dāng)前線程處理
invokeSubscriber(subscription, event);
}
break;
case ASYNC:
//如果訂閱方法要求線程模式是ASYNC，即要求在異步子線程進(jìn)行處理，則：
//將消息轉(zhuǎn)入子線程進(jìn)行處理
asyncPoster.enqueue(subscription, event);
break;
default:
//無效的線程模型，拋出異常
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}postToSubscription中主要是對線程模型進(jìn)行處理：
- POSTING：直接在當(dāng)前線程處理。
- MAIN：如果當(dāng)前已是主線程，則直接處理消息；如果當(dāng)前不是主線程，則通過handler轉(zhuǎn)入主線程處理。
- MAIN_ORDERED：主線程中串行處理，如果已經(jīng)設(shè)置主線程Handler，則將消息加入消息隊列等待loop進(jìn)行調(diào)度；如果沒有設(shè)置主線程Handler則直接在當(dāng)前線程處理。
- BACKGROUND：在子線程中處理，如果當(dāng)前是主線程，則將消息轉(zhuǎn)入子線程中再進(jìn)行處理；如果當(dāng)前已是子線程，則直接在當(dāng)前線程處理。
- *ASYNC：異步處理消息，不管當(dāng)前是主線程還是子線程，都需要加入新的子線程中再進(jìn)行處理。
直接處理消息的是通過invokeSubscriber方法，看名稱就是表示反射調(diào)用訂閱者的訂閱方法處理消息，那是不是呢？我們看看其源碼實現(xiàn)：
void invokeSubscriber(Subscription subscription, Object event) {
try {
//通過反射調(diào)用訂閱者的訂閱方法處理消息
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
} catch (InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
} catch (IllegalAccessException e) {
throw new IllegalStateException("Unexpected exception", e);
}
}就是通過反射調(diào)用訂閱者的訂閱方法，將消息傳遞給訂閱方法處理的；
（1）切換到主線程(MAIN)/主線程串行(MAIN_ORDERED)處理消息：
不管MAIN還是MAIN_ORDERED都是通過mainThreadPoster，將消息放入mainThreadPoster的隊列中，mainThreadPoster其實就是主線程中的Handler：
//使用mainThreadSupport創(chuàng)建主線程消息發(fā)布器
mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
public interface MainThreadSupport {
boolean isMainThread();
Poster createPoster(EventBus eventBus);
class AndroidHandlerMainThreadSupport implements MainThreadSupport {
private final Looper looper;
public AndroidHandlerMainThreadSupport(Looper looper) {
this.looper = looper;
}
@Override
public boolean isMainThread() {
return looper == Looper.myLooper();
}
@Override
public Poster createPoster(EventBus eventBus) {
//創(chuàng)建HandlerPoster作為mainThreadPoster
return new HandlerPoster(eventBus, looper, 10);
}
}
}
mainThreadPoster默認(rèn)是通過MainThreadSupport.AndroidHandlerMainThreadSupport.createPoster創(chuàng)建的，也就是mainThreadPoster默認(rèn)是HandlerPoster的實例對象，我們看看HandlerPoster：
public class HandlerPoster extends Handler implements Poster {
private final PendingPostQueue queue;
private final int maxMillisInsideHandleMessage;
private final EventBus eventBus;
private boolean handlerActive;
protected HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
super(looper);
this.eventBus = eventBus;
this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) {
//將消息進(jìn)行包裝
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this) {
//將消息加入等待隊列中
queue.enqueue(pendingPost);
if (!handlerActive) {
handlerActive = true;
//發(fā)送一個空消息
if (!sendMessage(obtainMessage())) {
throw new EventBusException("Could not send handler message");
}
}
}
}
@Override
public void handleMessage(Message msg) {
boolean rescheduled = false;
try {
long started = SystemClock.uptimeMillis();
while (true) {
//死循環(huán)
//從等待隊列中取出消息
PendingPost pendingPost = queue.poll();
if (pendingPost == null) {
synchronized (this) {
// Check again, this time in synchronized
pendingPost = queue.poll();
if (pendingPost == null) {
handlerActive = false;
//沒有等待處理的消息，則退出循環(huán)
return;
}
}
}
//回調(diào)EventBus的invokeSubscriber處理消息
eventBus.invokeSubscriber(pendingPost);
long timeInMethod = SystemClock.uptimeMillis() - started;
if (timeInMethod >= maxMillisInsideHandleMessage) {
//沒超過10毫秒重新發(fā)送空消息重新調(diào)度
if (!sendMessage(obtainMessage())) {
throw new EventBusException("Could not send handler message");
}
rescheduled = true;
return;
}
}
} finally {
handlerActive = rescheduled;
}
}
}- 切換到主線程主要使用的是主線程的Handler實現(xiàn)。
- 每次將消息加入等待隊列，然后Handler發(fā)送一個空消息。
- 在Handler的handleMessage中遍歷等待隊列消息出隊并進(jìn)行處理。
（2）切換到子線程(BACKGROUND)處理消息：
切換到子線程處理消息是通過backgroundPoster的enqueue方法，backgroundPoster是BackgroundPoster的實現(xiàn)類，我們看看其內(nèi)部實現(xiàn)：
final class BackgroundPoster implements Runnable, Poster {
private final PendingPostQueue queue;
private final EventBus eventBus;
private volatile boolean executorRunning;
BackgroundPoster(EventBus eventBus) {
this.eventBus = eventBus;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) {
//將消息進(jìn)行包裝
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized (this) {
//將消息加入等待隊列中
queue.enqueue(pendingPost);
if (!executorRunning) {
executorRunning = true;
//線程加入使用線程池中，等待回調(diào)run方法
eventBus.getExecutorService().execute(this);
}
}
}
@Override
public void run() {
try {
try {
while (true) {
//死循環(huán)
//從等待隊列中獲取等待處理的消息，1000表示如果隊列為空等待1000毫秒
PendingPost pendingPost = queue.poll(1000);
if (pendingPost == null) {
synchronized (this) {
// Check again, this time in synchronized
pendingPost = queue.poll();
if (pendingPost == null) {
executorRunning = false;
//如果消息為空，則退出循環(huán)
return;
}
}
}
//調(diào)用EventBus反射調(diào)用訂閱者的訂閱方法處理消息
eventBus.invokeSubscriber(pendingPost);
}
} catch (InterruptedException e) {
eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
}
} finally {
executorRunning = false;
}
}
}- 切換到子線程處理消息主要是將消息加入等待隊列，backgroundPoster本身是一個線程實現(xiàn)，將backgroundPoster本身加入線程池中運行。
- backgroundPoster線程執(zhí)行時遍歷等待隊列，從隊列中取出等待處理的消息，通過eventBus.invokeSubscriber處理消息。
其中默認(rèn)使用的線程池是緩存線程池：
executorService = builder.executorService;
public class EventBusBuilder {
private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
}
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
（3）異步消息(ASYNC)：
異步消息是通過asyncPoster的enqueue方法實現(xiàn)，asyncPoster是AsyncPoster的實例對象，它本身就是一個線程，我們看看其實現(xiàn)：
class AsyncPoster implements Runnable, Poster {
private final PendingPostQueue queue;
private final EventBus eventBus;
AsyncPoster(EventBus eventBus) {
this.eventBus = eventBus;
queue = new PendingPostQueue();
}
public void enqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
//將消息加入隊列中
queue.enqueue(pendingPost);
//線程加入線程池中
eventBus.getExecutorService().execute(this);
}
@Override
public void run() {
//每次取出一個消息
PendingPost pendingPost = queue.poll();
if(pendingPost == null) {
throw new IllegalStateException("No pending post available");
}
//調(diào)用EventBus反射調(diào)用訂閱者的訂閱方法處理消息
eventBus.invokeSubscriber(pendingPost);
}
}異步消息的實現(xiàn)主要是將消息加入等待隊列，然后將線程加入隊列，線程執(zhí)行是每次去等待隊列的一個消息（隊尾，先進(jìn)先出原則），最后調(diào)用EventBus反射調(diào)用訂閱者的訂閱方法處理消息。
異步消息使用的線程池跟BACKGROUND模式使用的線程池是同一個，都是緩存線程池，與BACKGROUND的區(qū)別是：
- 異步消息每次都將線程加入線程池中。
- 而BACKGROUND則不需要每次。
- 異步消息線程執(zhí)行每次只去隊尾消息進(jìn)行處理，而BACKGROUND線程執(zhí)行時會處理隊列中的所有消息。
總結(jié)：
- EventBus基于觀察者模式，其首先需要先將訂閱者與消息類型進(jìn)行注冊到一個消息/訂閱者列表map中，發(fā)布消息時從map找找到對應(yīng)的訂閱者并調(diào)用相應(yīng)的訂閱方法進(jìn)行處理消息。
- 注冊時通過訂閱者class通過反射收集subscribe注解修飾的方法列表及注解信息，最終注冊到消息/訂閱者列表map中，這個運行時注解是先對耗時的；所以EventBus提供了編譯期注解處理器來做個收集的工作，降低性能損耗。
- 發(fā)布消息時根據(jù)消息類型class從消息/訂閱者列表map中找到對應(yīng)的訂閱者列表并進(jìn)行一一處理，同時根據(jù)注解中的線程模式進(jìn)行線程切換處理。
責(zé)任編輯：姜華
來源：
Android開發(fā)編程
