轉自:http://blog.csdn.net/yuanzeyao/article/details/38174537
尊重原創:http://blog.csdn.net/yuanzeyao/article/details/38174537
代碼下載:http://download.csdn.net/detail/yuanzeyao2008/7684041
在編程過程中,當我們想通知其他組件某些事情發生時,我們通常使用觀察者模式,正式因爲觀察者模式非常常見,所以在jdk1.5中已經幫助我們實現了觀察者模式,我們只需要簡單的繼承一些類就可以快速使用觀察者模式,在Android中也有一個類似功能的開源庫EventBus,可以很方便的幫助我們實現觀察者模式,那麼我們就開始學習如何使用EventBus.
在接下來的內容中,我首先會介紹如何使用EventBus,然後再簡單的學習一下EventBus的底層實現原理,因爲僅僅學習如何使用總是感覺內心不夠踏實,萬一哪天出了Bug也無從下手,瞭解了它的基本實現後,就會用得遊刃有餘。好了 廢話不多說,下面開始學習吧
1、下載EventBus庫:
EvnetBus的下載地址:https://github.com/greenrobot/EventBus.git
2、將EventBus.jar放入自己工程的libs目錄即可
3、定義一個事件,這個事件一旦被EventBus分發出去就是代表某一件事情發生了,這個事件就是某個觀察者關心的事情(不需要繼承任何類)
4、定義觀察者,然後將該觀察者註冊到EventBus
5、由EventBus分發事件,告知觀察者某一件事情發生了
6、使用完成後從EventBus中反註冊觀察者。
熟悉觀察者模式的朋友肯定對於上面的流程非常熟悉,其實和觀察模式基本是一樣的。但是也是有區別的。在觀察者模式中,所有的觀察者都需要實現一個接口,這個接口有一個統一的方法如:
public void onUpdate();
然後當某一個事件發生時,某個對象會調用觀察者的onUpdate方法通知觀察者某件事情發生了,但是在EventBus中不需要這樣,EventBus中是這樣實現的:
在EventBus中的觀察者通常有四種訂閱函數(就是某件事情發生被調用的方法)
1、onEvent
2、onEventMainThread
3、onEventBackground
4、onEventAsync
這四種訂閱函數都是使用onEvent開頭的,它們的功能稍有不同,在介紹不同之前先介紹兩個概念:
告知觀察者事件發生時通過EventBus.post函數實現,這個過程叫做事件的發佈,觀察者被告知事件發生叫做事件的接收,是通過下面的訂閱函數實現的。
onEvent:如果使用onEvent作爲訂閱函數,那麼該事件在哪個線程發佈出來的,onEvent就會在這個線程中運行,也就是說發佈事件和接收事件線程在同一個線程。使用這個方法時,在onEvent方法中不能執行耗時操作,如果執行耗時操作容易導致事件分發延遲。
onEventMainThread:如果使用onEventMainThread作爲訂閱函數,那麼不論事件是在哪個線程中發佈出來的,onEventMainThread都會在UI線程中執行,接收事件就會在UI線程中運行,這個在Android中是非常有用的,因爲在Android中只能在UI線程中跟新UI,所以在onEvnetMainThread方法中是不能執行耗時操作的。
onEvnetBackground:如果使用onEventBackgrond作爲訂閱函數,那麼如果事件是在UI線程中發佈出來的,那麼onEventBackground就會在子線程中運行,如果事件本來就是子線程中發佈出來的,那麼onEventBackground函數直接在該子線程中執行。
onEventAsync:使用這個函數作爲訂閱函數,那麼無論事件在哪個線程發佈,都會創建新的子線程在執行onEventAsync.
下面就通過一個實例來看看這幾個訂閱函數的使用吧
1、定義事件:
- public class AsyncEvent
- {
- private static final String TAG = "AsyncEvent";
- public String msg;
- public AsyncEvent(String msg)
- {
- this.msg=msg;
- }
- }
其他的事件我就不都貼出來了,我會提供代碼的下載的。
2、創建觀察者(也可以叫訂閱者),並實現訂閱方法
- public class MainActivity extends Activity
- {
- @Override
- protected void onCreate(Bundle savedInstanceState)
- {
- super.onCreate(savedInstanceState);
- setContentView(R.layout.activity_main);
- //註冊EventBus
- EventBus.getDefault().register(this);
- }
- // click--------------------------------------start----------------------
- public void methodPost(View view)
- {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new PostEvent("PostEvent"));
- }
- public void methodMain(View view)
- {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new MainEvent("MainEvent"));
- }
- public void methodBack(View view)
- {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new BackEvent("BackEvent"));
- }
- public void methodAsync(View view)
- {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new AsyncEvent("AsyncEvent"));
- }
- public void methodSubPost(View view)
- {
- new Thread()
- {
- public void run() {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new PostEvent("PostEvent"));
- };
- }.start();
- }
- public void methodSubMain(View view)
- {
- new Thread()
- {
- public void run() {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new MainEvent("MainEvent"));
- };
- }.start();
- }
- public void methodSubBack(View view)
- {
- new Thread()
- {
- public void run() {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new BackEvent("BackEvent"));
- };
- }.start();
- }
- public void methodSubAsync(View view)
- {
- new Thread()
- {
- public void run() {
- Log.d("yzy", "PostThread-->"+Thread.currentThread().getId());
- EventBus.getDefault().post(new AsyncEvent("AsyncEvent"));
- };
- }.start();
- }
- //click--------------------end------------------------------
- //Event-------------------------start-------------------------------
- /**
- * 使用onEvent來接收事件,那麼接收事件和分發事件在一個線程中執行
- * @param event
- */
- public void onEvent(PostEvent event)
- {
- Log.d("yzy", "OnEvent-->"+Thread.currentThread().getId());
- }
- /**
- * 使用onEventMainThread來接收事件,那麼不論分發事件在哪個線程運行,接收事件永遠在UI線程執行,
- * 這對於android應用是非常有意義的
- * @param event
- */
- public void onEventMainThread(MainEvent event)
- {
- Log.d("yzy", "onEventMainThread-->"+Thread.currentThread().getId());
- }
- /**
- * 使用onEventBackgroundThread來接收事件,如果分發事件在子線程運行,那麼接收事件直接在同樣線程
- * 運行,如果分發事件在UI線程,那麼會啓動一個子線程運行接收事件
- * @param event
- */
- public void onEventBackgroundThread(BackEvent event)
- {
- Log.d("yzy", "onEventBackgroundThread-->"+Thread.currentThread().getId());
- }
- /**
- * 使用onEventAsync接收事件,無論分發事件在(UI或者子線程)哪個線程執行,接收都會在另外一個子線程執行
- * @param event
- */
- public void onEventAsync(AsyncEvent event)
- {
- Log.d("yzy", "onEventAsync-->"+Thread.currentThread().getId());
- }
- //Event------------------------------end-------------------------------------
- @Override
- protected void onDestroy()
- {
- //取消註冊EventBus
- EventBus.getDefault().unregister(this);
- super.onDestroy();
- }
- }
說明:向EvnetBus中註冊訂閱者使用EventBus.register方法,取消訂閱者使用EvnetBus.unregister方法,通知訂閱者某件事情發生,調用EventBus.post方法,具體使用可以看上面的例子。在上面的例子中我創建了4中事件,並且分別中UI線程中post四個事件和在子線程中post四個事件,然後分別打印四種訂閱函數所在線程的線程id.
EventBus的使用都在這裏了,實在是很簡單,但是如果我們在此基礎上理解EvnetBus的原理,那麼我們就能非常輕鬆的使用EventBus了。
就從EvnetBus的入口開始看吧:EventBus.register
- public void register(Object subscriber) {
- register(subscriber, DEFAULT_METHOD_NAME, false, 0);
- }
其實調用的就是同名函數register,它的四個參數意義分別是:
subscriber:就是要註冊的一個訂閱者,
methodName:就是訂閱者默認的訂閱函數名,其實就是“onEvent”
sticky:表示是否是粘性的,一般默認都是false,除非你調用registerSticky方法了
priority:表示事件的優先級,默認就行,
接下來我們就看看這個函數具體幹了什麼
- private synchronized void 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);
- }
- }
通過一個findSubscriberMethods方法找到了一個訂閱者中的所有訂閱方法,返回一個 List<SubscriberMethod>,進入到findSubscriberMethods看看如何實現的
- List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass, String eventMethodName) {
- //通過訂閱者類名+"."+"onEvent"創建一個key
- String key = subscriberClass.getName() + '.' + eventMethodName;
- List<SubscriberMethod> subscriberMethods;
- synchronized (methodCache) {
- //判斷是否有緩存,有緩存直接返回緩存
- subscriberMethods = methodCache.get(key);
- }
- //第一次進來subscriberMethods肯定是Null
- if (subscriberMethods != null) {
- return subscriberMethods;
- }
- 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.getMethods();
- for (Method method : methods) {
- String methodName = method.getName();
- //只找以onEvent開頭的方法
- if (methodName.startsWith(eventMethodName)) {
- int modifiers = method.getModifiers();
- //判斷訂閱者是否是public的,並且是否有修飾符,看來訂閱者只能是public的,並且不能被final,static等修飾
- if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
- //獲得訂閱函數的參數
- Class<?>[] parameterTypes = method.getParameterTypes();
- //看了參數的個數只能是1個
- if (parameterTypes.length == 1) {
- //獲取onEvent後面的部分
- String modifierString = methodName.substring(eventMethodName.length());
- ThreadMode threadMode;
- if (modifierString.length() == 0) {
- //訂閱函數爲onEvnet
- //記錄線程模型爲PostThread,意義就是發佈事件和接收事件在同一個線程執行,詳細可以參考我對於四個訂閱函數不同點分析
- threadMode = ThreadMode.PostThread;
- } else if (modifierString.equals("MainThread")) {
- //對應onEventMainThread
- threadMode = ThreadMode.MainThread;
- } else if (modifierString.equals("BackgroundThread")) {
- //對應onEventBackgrondThread
- threadMode = ThreadMode.BackgroundThread;
- } else if (modifierString.equals("Async")) {
- //對應onEventAsync
- 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());
- String methodKey = methodKeyBuilder.toString();
- if (eventTypesFound.add(methodKey)) {
- // Only add if not already found in a sub class
- //封裝一個訂閱方法對象,這個對象包含Method對象,threadMode對象,eventType對象
- 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();
- }
- //最後加入緩存,第二次使用直接從緩存拿
- if (subscriberMethods.isEmpty()) {
- throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called "
- + eventMethodName);
- } else {
- synchronized (methodCache) {
- methodCache.put(key, subscriberMethods);
- }
- return subscriberMethods;
- }
- }
對於這個方法的講解都在註釋裏面了,這裏就不在重複敘述了,到了這裏我們就找到了一個訂閱者的所有的訂閱方法
我們回到register方法:
- for (SubscriberMethod subscriberMethod : subscriberMethods) {
- subscribe(subscriber, subscriberMethod, sticky, priority);
- }
對每一個訂閱方法,對其調用subscribe方法,進入該方法看看到底幹了什麼
- private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {
- subscribed = true;
- //從訂閱方法中拿到訂閱事件的類型
- Class<?> eventType = subscriberMethod.eventType;
- //通過訂閱事件類型,找到所有的訂閱(Subscription),訂閱中包含了訂閱者,訂閱方法
- 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 {
- //如果有訂閱列表,檢查是否已經加入過
- for (Subscription subscription : subscriptions) {
- if (subscription.equals(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 || newSubscription.priority > subscriptions.get(i).priority) {
- subscriptions.add(i, newSubscription);
- break;
- }
- }
- //將這個訂閱事件加入到訂閱者的訂閱事件列表中
- List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
- if (subscribedEvents == null) {
- subscribedEvents = new ArrayList<Class<?>>();
- typesBySubscriber.put(subscriber, subscribedEvents);
- }
- subscribedEvents.add(eventType);
- //這個是對粘性事件的,暫時不討論
- if (sticky) {
- Object stickyEvent;
- synchronized (stickyEvents) {
- stickyEvent = stickyEvents.get(eventType);
- }
- if (stickyEvent != null) {
- postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
- }
- }
- }
好了,到這裏差不多register方法分析完了,大致流程就是這樣的,我們總結一下:
1、找到被註冊者中所有的訂閱方法。
2、依次遍歷訂閱方法,找到EventBus中eventType對應的訂閱列表,然後根據當前訂閱者和訂閱方法創建一個新的訂閱加入到訂閱列表
3、找到EvnetBus中subscriber訂閱的事件列表,將eventType加入到這個事件列表。
所以對於任何一個訂閱者,我們可以找到它的 訂閱事件類型列表,通過這個訂閱事件類型,可以找到在訂閱者中的訂閱函數。
register分析完了就分析一下post吧,這個分析完了,EventBus的原理差不多也完了...
- public void post(Object event) {
- //這個EventBus中只有一個,差不多是個單例吧,具體不用細究
- PostingThreadState postingState = currentPostingThreadState.get();
- List<Object> eventQueue = postingState.eventQueue;
- //將事件放入隊列
- eventQueue.add(event);
- if (postingState.isPosting) {
- return;
- } else {
- 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;
- }
- }
- }
post裏面沒有什麼具體邏輯,它的功能主要是調用postSingleEvent完成的,進入到這個函數看看吧
- private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
- Class<? extends Object> eventClass = event.getClass();
- //找到eventClass對應的事件,包含父類對應的事件和接口對應的事件
- List<Class<?>> eventTypes = findEventTypes(eventClass);
- boolean subscriptionFound = false;
- int countTypes = eventTypes.size();
- for (int h = 0; h < countTypes; h++) {
- Class<?> clazz = eventTypes.get(h);
- CopyOnWriteArrayList<Subscription> subscriptions;
- synchronized (this) {
- //找到訂閱事件對應的訂閱,這個是通過register加入的(還記得嗎....)
- subscriptions = subscriptionsByEventType.get(clazz);
- }
- 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;
- }
- }
- subscriptionFound = true;
- }
- }
- //如果沒有訂閱發現,那麼會Post一個NoSubscriberEvent事件
- if (!subscriptionFound) {
- Log.d(TAG, "No subscribers registered for event " + eventClass);
- if (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) {
- //這個threadMode是怎麼傳入的,仔細想想?是不是根據onEvent,onEventMainThread,onEventBackground,onEventAsync決定的?
- case PostThread:
- //直接在本線程中調用訂閱函數
- invokeSubscriber(subscription, event);
- break;
- case MainThread:
- if (isMainThread) {
- //如果直接在主線程,那麼直接在本現場中調用訂閱函數
- invokeSubscriber(subscription, event);
- } else {
- //如果不在主線程,那麼通過handler實現在主線程中執行,具體我就不跟蹤了
- mainThreadPoster.enqueue(subscription, event);
- }
- break;
- case BackgroundThread:
- if (isMainThread) {
- //如果主線程,創建一個runnable丟入線程池中
- 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);
- }
- }
好了 ,對於EventBus的分析就到這裏了,有哪裏分析不對的,歡迎拍磚。。。