项目地址 :https://github.com/greenrobot/EventBus
这个项目个人感觉就是为了解决回调事件过多的,比方说A函数在做完以后 要调用b类的c函数,那我们通常的做法就是 定义一个接口 然后再A函数所属的类里面注册这个接口。
然后a函数做完以后 直接调用这个接口即可。但是这种方法写多了以后确实很麻烦,于是EventBus就是用来解决这种场景的。
和以往一样,我们只解析他的源码,如果你要学习他的用法请自行谷歌。
我们就从register函数开始说起。
1 private synchronized void register(Object subscriber, boolean sticky, int priority) { 2 //这个list就是方法的集合 3 List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass()); 4 //这个循环的目的就是为了用 方法对象 来构造 Subscription对象 5 for (SubscriberMethod subscriberMethod : subscriberMethods) { 6 subscribe(subscriber, subscriberMethod, sticky, priority); 7 } 8 }
首先来看一下SubscriberMethod这个类,
1 /* 2 * Copyright (C) 2012 Markus Junginger, greenrobot (http://greenrobot.de) 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package de.greenrobot.event; 17 18 import java.lang.reflect.Method; 19 20 import android.util.Log; 21 22 /** 23 * 这个类就是描述方法用的 24 */ 25 final class SubscriberMethod { 26 final Method method; 27 final ThreadMode threadMode; 28 final Class<?> eventType; 29 /** Used for efficient comparison */ 30 /** 31 * 这个methodString 实际上就是用来描述SubscriberMethod对象的,尤其是在重写的equals方法里 起到关键的作用 32 * 就类似于这种结构 33 * com.example.administrator.eventbustest.ItemDetailFragment#onEventMainThread(com.example.administrator.eventbustest.Item 34 *其实也很好理解就是 包名+类名#方法名(参数的类型 35 * 注意这里参数的类型也是全路径名 包名+类名 36 */ 37 String methodString; 38 39 SubscriberMethod(Method method, ThreadMode threadMode, Class<?> eventType) { 40 this.method = method; 41 this.threadMode = threadMode; 42 this.eventType = eventType; 43 } 44 45 @Override 46 public boolean equals(Object other) { 47 if (other instanceof SubscriberMethod) { 48 checkMethodString(); 49 SubscriberMethod otherSubscriberMethod = (SubscriberMethod) other; 50 otherSubscriberMethod.checkMethodString(); 51 // Don't use method.equals because of http://code.google.com/p/android/issues/detail?id=7811#c6 52 return methodString.equals(otherSubscriberMethod.methodString); 53 } else { 54 return false; 55 } 56 } 57 58 private synchronized void checkMethodString() { 59 if (methodString == null) { 60 // Method.toString has more overhead, just take relevant parts of the method 61 StringBuilder builder = new StringBuilder(64); 62 builder.append(method.getDeclaringClass().getName()); 63 builder.append('#').append(method.getName()); 64 builder.append('(').append(eventType.getName()); 65 methodString = builder.toString(); 66 } 67 } 68 69 @Override 70 public int hashCode() { 71 return method.hashCode(); 72 } 73 }
然后我们来看看这个SubscriberMethod对象组成的集合 是怎么构造出来的。
1 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) { 2 String key = subscriberClass.getName(); 3 List<SubscriberMethod> subscriberMethods; 4 synchronized (methodCache) { 5 subscriberMethods = methodCache.get(key); 6 } 7 8 if (subscriberMethods != null) { 9 return subscriberMethods; 10 } 11 subscriberMethods = new ArrayList<SubscriberMethod>(); 12 Class<?> clazz = subscriberClass; 13 HashSet<String> eventTypesFound = new HashSet<String>(); 14 StringBuilder methodKeyBuilder = new StringBuilder(); 15 while (clazz != null) { 16 String name = clazz.getName(); 17 //这个地方判断如果是这些类,那么就直接跳出这个while循环 18 //注意name的值 也是包名+类名,所以这里就是过滤掉基础的sdk的那些方法 19 //如果你有引用其他公共lib库的话 你也可以过滤他们的包, 20 if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) { 21 // Skip system classes, this just degrades performance 22 break; 23 } 24 25 // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again) 26 Method[] methods = clazz.getDeclaredMethods(); 27 for (Method method : methods) { 28 String methodName = method.getName(); 29 Log.e("burning", "methodName == " + methodName); 30 //只有那些以onEvent开头的方法才是我们需要的 31 if (methodName.startsWith(ON_EVENT_METHOD_NAME)) { 32 int modifiers = method.getModifiers(); 33 //注意这个地方判断方法属性的技巧 与 操作 34 if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { 35 Class<?>[] parameterTypes = method.getParameterTypes(); 36 //如果参数只有一个 37 if (parameterTypes.length == 1) { 38 String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.length()); 39 //取ThreadMode 40 ThreadMode threadMode; 41 if (modifierString.length() == 0) { 42 threadMode = ThreadMode.PostThread; 43 } else if (modifierString.equals("MainThread")) { 44 threadMode = ThreadMode.MainThread; 45 } else if (modifierString.equals("BackgroundThread")) { 46 threadMode = ThreadMode.BackgroundThread; 47 } else if (modifierString.equals("Async")) { 48 threadMode = ThreadMode.Async; 49 } else { 50 if (skipMethodVerificationForClasses.containsKey(clazz)) { 51 continue; 52 } else { 53 throw new EventBusException("Illegal onEvent method, check for typos: " + method); 54 } 55 } 56 Class<?> eventType = parameterTypes[0]; 57 methodKeyBuilder.setLength(0); 58 methodKeyBuilder.append(methodName); 59 methodKeyBuilder.append('>').append(eventType.getName()); 60 //onEventMainThread>java.lang.String 61 //methodKey就是上面的形式,可以看出来是方法名>参数 的格式 62 String methodKey = methodKeyBuilder.toString(); 64 //这个地方先去这个hashset里面add这个key,当然了,如果你这个hashset里面已经有这个key 65 //那必然是add不成功的,只有add成功返回true以后括号内的代码才会得到执行 66 if (eventTypesFound.add(methodKey)) { 67 // Only add if not already found in a sub class 68 //这个地方就是构造SubscriberMethod对象放到list里 准备返回 69 subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType)); 70 } 71 } 72 } else if (!skipMethodVerificationForClasses.containsKey(clazz)) { 73 Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + clazz + "." 74 + methodName); 75 } 76 } 77 } 78 //这里注意还在大的while循环内,所以你传进去的类自己查完一遍方法以后 还会去找他的父类继续查询方法 79 //一直遍历到父类为 那些java android开头的基类为止! 80 clazz = clazz.getSuperclass(); 81 82 } 83 if (subscriberMethods.isEmpty()) { 84 throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called " 85 + ON_EVENT_METHOD_NAME); 86 } else { 87 synchronized (methodCache) { 88 methodCache.put(key, subscriberMethods); 89 } 90 return subscriberMethods; 91 } 92 }
然后我们来看看register函数里面 5-6行 那个循环遍历做了什么
首先我们看看这个循环调用的方法:
1 /** 2 * @param subscriber 方法所述的类的 包名+类名 3 * @param subscriberMethod 4 * @param sticky 5 * @param priority 6 */ 7 private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) { 8 //这个eventtype就是方法的参数的类名 9 Class<?> eventType = subscriberMethod.eventType; 10 11 CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); 12 Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority); 13 if (subscriptions == null) { 14 subscriptions = new CopyOnWriteArrayList<Subscription>(); 15 subscriptionsByEventType.put(eventType, subscriptions); 16 } else { 17 if (subscriptions.contains(newSubscription)) { 18 throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " 19 + eventType); 20 } 21 } 22 23 // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again) 24 // subscriberMethod.method.setAccessible(true); 25 //这个就是优先级高的位置在前面 26 int size = subscriptions.size(); 27 for (int i = 0; i <= size; i++) { 28 if (i == size || newSubscription.priority > subscriptions.get(i).priority) { 29 subscriptions.add(i, newSubscription); 30 break; 31 } 32 } 33 34 List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber); 35 if (subscribedEvents == null) { 36 subscribedEvents = new ArrayList<Class<?>>(); 37 typesBySubscriber.put(subscriber, subscribedEvents); 38 } 39 subscribedEvents.add(eventType); 40 41 if (sticky) { 42 43 if (eventInheritance) { 44 // Existing sticky events of all subclasses of eventType have to be considered. 45 // Note: Iterating over all events may be inefficient with lots of sticky events, 46 // thus data structure should be changed to allow a more efficient lookup 47 // (e.g. an additional map storing sub classes of super classes: Class -> List<Class>). 48 Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet(); 49 for (Map.Entry<Class<?>, Object> entry : entries) { 50 Class<?> candidateEventType = entry.getKey(); 51 if (eventType.isAssignableFrom(candidateEventType)) { 52 Object stickyEvent = entry.getValue(); 53 checkPostStickyEventToSubscription(newSubscription, stickyEvent); 54 } 55 } 56 } else { 57 Object stickyEvent = stickyEvents.get(eventType); 58 checkPostStickyEventToSubscription(newSubscription, stickyEvent); 59 } 60 } 61 }
10-13行 我们可以看出来 这个函数 主要是为了构造subscription这个list对象。
/** * 这个map 存储方法的地方 key就是eventType,value就是copyOnWriteArrayList value就是方法的一切 */ private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
我们可以看看这个类是什么
1 /** 2 * 这个类里面包含有SubscriberMethod类对象, 3 * subscriber 4 */ 5 final class Subscription { 6 //这个实际上就是描述方法所属的类的 7 final Object subscriber; 8 //描述方法的类 9 final SubscriberMethod subscriberMethod; 10 //优先级 11 final int priority; 12 /** 13 * Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery 14 * {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions. 15 */ 16 volatile boolean active; 17 18 Subscription(Object subscriber, SubscriberMethod subscriberMethod, int priority) { 19 this.subscriber = subscriber; 20 this.subscriberMethod = subscriberMethod; 21 this.priority = priority; 22 active = true; 23 } 24 25 @Override 26 public boolean equals(Object other) { 27 if (other instanceof Subscription) { 28 Subscription otherSubscription = (Subscription) other; 29 return subscriber == otherSubscription.subscriber 30 && subscriberMethod.equals(otherSubscription.subscriberMethod); 31 } else { 32 return false; 33 } 34 } 35 36 @Override 37 public int hashCode() { 38 return subscriber.hashCode() + subscriberMethod.methodString.hashCode(); 39 } 40 }
所以总结起来,SubscriberMethod 就是对方法的描述,而我们的SubscriberMethod 实际上就是Subscription的子集,Subscription除了有描述方法的对象以外,还有这个方法所属的类,
而我们的register方法总体来说 就是先通过findSubscriberMethods方法 取得我们注册类(就是你register调用的时候传的this)所需要的的那些方法(注意不是每个方法都需要 只选择自己需要的)
然后把这些方法 做一个list,最后再通过便利这个list : 用每一个SubscriberMethod 对象和这个方法所需的类(包名+类名) 来构造出一个Subscription对象,然后把这个对象
存储在SubscriptionsByEventType里,注意这个map的key 实际上就是eventType,而value则代表方法的list,换句话说。
这个SubscriptionsByEventType 是一个键值对,它的key 实际上就是我们的类名,value则是这个类里面我们需要存储的方法的list!
这就是register的大致流程,我们再来看看post 流程即可。
1 /** 2 * Posts the given event to the event bus. 3 */ 4 public void post(Object event) { 5 PostingThreadState postingState = currentPostingThreadState.get(); 6 //这个地方可以看出来是每次有人调用post方法的时候 都会从postingState取出这个队列,然后把这个事件放到这个队列里 7 List<Object> eventQueue = postingState.eventQueue; 8 eventQueue.add(event); 9 10 //这个判断isPosting 主要是为了保证同一时间只能有一个线程在处理括号体里的内容 11 //currentPostingThreadState 是用threadlocal来构造的 所以保证了同步性 12 if (!postingState.isPosting) { 13 postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper(); 14 postingState.isPosting = true; 15 if (postingState.canceled) { 16 throw new EventBusException("Internal error. Abort state was not reset"); 17 } 18 try { 19 while (!eventQueue.isEmpty()) { 20 //队列不为空就处理 21 postSingleEvent(eventQueue.remove(0), postingState); 22 } 23 } finally { 24 postingState.isPosting = false; 25 postingState.isMainThread = false; 26 } 27 } 28 }
先看看第5行的postingState是什么
1 /** 2 * 静态类,里面除了有一个队列以外,还有几个标志位,以及一个Subscription 3 */ 4 final static class PostingThreadState { 5 final List<Object> eventQueue = new ArrayList<Object>(); 6 boolean isPosting; 7 boolean isMainThread; 8 Subscription subscription; 9 Object event; 10 boolean canceled; 11 }
这个地方就能看出来,我们每次调用post 都是往eventQueue里面添加一个事件,而12行开始则是从队列里面
取事件来处理,注意12行开始 一次性只能允许一个线程使用~同步的
然后继续看是怎么处理的。
1 /** 2 * @param event 方法的参数的类名 3 * @param postingState 4 * @throws Error 5 */ 6 private void postSingleEvent(Object event, PostingThreadState postingState) throws Error { 7 8 Class<?> eventClass = event.getClass(); 9 boolean subscriptionFound = false; 10 11 if (eventInheritance) { 12 List<Class<?>> eventTypes = lookupAllEventTypes(eventClass); 13 int countTypes = eventTypes.size(); 14 for (int h = 0; h < countTypes; h++) { 15 Class<?> clazz = eventTypes.get(h); 16 //这个地方就是取出Subscription对象的的所有信息!发消息也是在这个函数里发送的 17 subscriptionFound |= postSingleEventForEventType(event, postingState, clazz); 18 } 19 } else { 20 subscriptionFound = postSingleEventForEventType(event, postingState, eventClass); 21 } 22 if (!subscriptionFound) { 23 if (logNoSubscriberMessages) { 24 Log.d(TAG, "No subscribers registered for event " + eventClass); 25 } 26 if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class && 27 eventClass != SubscriberExceptionEvent.class) { 28 post(new NoSubscriberEvent(this, event)); 29 } 30 } 31 }
继续跟进去
1 private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) { 2 CopyOnWriteArrayList<Subscription> subscriptions; 3 synchronized (this) { 4 subscriptions = subscriptionsByEventType.get(eventClass); 5 } 6 if (subscriptions != null && !subscriptions.isEmpty()) { 7 for (Subscription subscription : subscriptions) { 8 postingState.event = event; 9 postingState.subscription = subscription; 10 boolean aborted = false; 11 try { 12 //这个地方就是真正发消息的地方了 13 postToSubscription(subscription, event, postingState.isMainThread); 14 aborted = postingState.canceled; 15 } finally { 16 postingState.event = null; 17 postingState.subscription = null; 18 postingState.canceled = false; 19 } 20 if (aborted) { 21 break; 22 } 23 } 24 return true; 25 } 26 return false; 27 }
可以看出来 2-6行 就是从我们register流程里存储的键值对里 把我们存放的方法给取出来。,
取出来以后 就可以反射调用他们的方法了
1 /** 2 * 这个类就是反射执行方法 并且是最终执行回调方法的地方 3 * 4 * @param subscription 5 * @param event 6 * @param isMainThread 7 */ 8 private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) { 9 switch (subscription.subscriberMethod.threadMode) { 10 case PostThread: 11 invokeSubscriber(subscription, event); 12 break; 13 case MainThread: 14 if (isMainThread) { 15 invokeSubscriber(subscription, event); 16 } else { 17 mainThreadPoster.enqueue(subscription, event); 18 } 19 break; 20 case BackgroundThread: 21 if (isMainThread) { 22 backgroundPoster.enqueue(subscription, event); 23 } else { 24 invokeSubscriber(subscription, event); 25 } 26 break; 27 case Async: 28 asyncPoster.enqueue(subscription, event); 29 break; 30 default: 31 throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode); 32 } 33 }
13-18行 这个case 如果是主线程,那么就直接反射方法,如果不是的话 则要放到主线程handler里执行。
1 private final HandlerPoster mainThreadPoster;
1 //这个就是主线程handler初始化 2 mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
1 /* 2 * Copyright (C) 2012 Markus Junginger, greenrobot (http://greenrobot.de) 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package de.greenrobot.event; 17 18 import android.os.Handler; 19 import android.os.Looper; 20 import android.os.Message; 21 import android.os.SystemClock; 22 23 final class HandlerPoster extends Handler { 24 25 private final PendingPostQueue queue; 26 private final int maxMillisInsideHandleMessage; 27 private final EventBus eventBus; 28 private boolean handlerActive; 29 30 HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) { 31 super(looper); 32 this.eventBus = eventBus; 33 this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage; 34 queue = new PendingPostQueue(); 35 } 36 37 void enqueue(Subscription subscription, Object event) { 38 PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); 39 synchronized (this) { 40 queue.enqueue(pendingPost); 41 if (!handlerActive) { 42 handlerActive = true; 43 if (!sendMessage(obtainMessage())) { 44 throw new EventBusException("Could not send handler message"); 45 } 46 } 47 } 48 } 49 50 @Override 51 public void handleMessage(Message msg) { 52 boolean rescheduled = false; 53 try { 54 long started = SystemClock.uptimeMillis(); 55 while (true) { 56 PendingPost pendingPost = queue.poll(); 57 if (pendingPost == null) { 58 synchronized (this) { 59 // Check again, this time in synchronized 60 pendingPost = queue.poll(); 61 if (pendingPost == null) { 62 handlerActive = false; 63 return; 64 } 65 } 66 } 67 eventBus.invokeSubscriber(pendingPost); 68 long timeInMethod = SystemClock.uptimeMillis() - started; 69 if (timeInMethod >= maxMillisInsideHandleMessage) { 70 if (!sendMessage(obtainMessage())) { 71 throw new EventBusException("Could not send handler message"); 72 } 73 rescheduled = true; 74 return; 75 } 76 } 77 } finally { 78 handlerActive = rescheduled; 79 } 80 } 81 }
51-77行 就是我们实际最终调用的地方。
同样的 我们在看看20-26行的这个background这个case
1 final class BackgroundPoster implements Runnable { 2 3 private final PendingPostQueue queue; 4 private final EventBus eventBus; 5 6 private volatile boolean executorRunning; 7 8 BackgroundPoster(EventBus eventBus) { 9 this.eventBus = eventBus; 10 queue = new PendingPostQueue(); 11 } 12 13 public void enqueue(Subscription subscription, Object event) { 14 PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); 15 synchronized (this) { 16 queue.enqueue(pendingPost); 17 if (!executorRunning) { 18 executorRunning = true; 19 eventBus.getExecutorService().execute(this); 20 } 21 } 22 } 23 24 @Override 25 public void run() { 26 try { 27 try { 28 while (true) { 29 PendingPost pendingPost = queue.poll(1000); 30 if (pendingPost == null) { 31 synchronized (this) { 32 // Check again, this time in synchronized 33 pendingPost = queue.poll(); 34 if (pendingPost == null) { 35 executorRunning = false; 36 return; 37 } 38 } 39 } 40 eventBus.invokeSubscriber(pendingPost); 41 } 42 } catch (InterruptedException e) { 43 Log.w("Event", Thread.currentThread().getName() + " was interruppted", e); 44 } 45 } finally { 46 executorRunning = false; 47 } 48 }
一看就知道 他是runnable对象 必然是在后台 在子线程内执行,同时他也是一次性只能做一次操作,完成一个事件,
最后我们来看看Async这个case:
1 /* 2 * Copyright (C) 2012 Markus Junginger, greenrobot (http://greenrobot.de) 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 package de.greenrobot.event; 17 18 19 /** 20 * Posts events in background. 21 * 22 * @author Markus 并发执行任务,在线程池内执行 23 */ 24 class AsyncPoster implements Runnable { 25 26 private final PendingPostQueue queue; 27 private final EventBus eventBus; 28 29 AsyncPoster(EventBus eventBus) { 30 this.eventBus = eventBus; 31 queue = new PendingPostQueue(); 32 } 33 34 public void enqueue(Subscription subscription, Object event) { 35 PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); 36 queue.enqueue(pendingPost); 37 eventBus.getExecutorService().execute(this); 38 } 39 40 @Override 41 public void run() { 42 PendingPost pendingPost = queue.poll(); 43 if(pendingPost == null) { 44 throw new IllegalStateException("No pending post available"); 45 } 46 eventBus.invokeSubscriber(pendingPost); 47 } 48 49 }
这个地方和background相同的就是也是在非主线程,在子线程内执行,但是这个地方是在线程池内执行,可以并发执行多个任务,
而我们的background 则一次性只能执行一个任务,这是2者之间的区别。