閒在家裏？看看EventBus解析，跟我一塊兒一塊兒手寫EventBus

時間 2020-02-20

標籤閒在家裏看看 eventbus 解析一塊兒手寫简体版

原文原文鏈接

前言

原本通知這週一復工的，結果好像事情並無簡單，又推遲到下週1了，還要在家辦公一段時間，昨天有粉絲問我怎麼沒有更文，昨天分批次去公司開了一下午的會議，索性你們人數分批開會都帶了口罩，因此一點都不慌，你們出門都記得戴口罩，勤洗手~（在家辦公仍是蠻快樂的，能夠邊唱歌邊辦公^_^）git

前幾天更新了OKHTTP和Retrofit的解析，今天更最後一篇EventBus的解析。github

把最近的知識也整理彙總了一份，打算和以前的知識作個彙總的PDF，有興趣的能夠借鑑學習一下
面試

上圖知識彙總的PDF相關內容後續GitHub更新,想衝擊金三銀四的小夥伴能夠找找看看，歡迎star
（順手留下GitHub連接，須要獲取相關面試等內容的能夠本身去找）
https://github.com/xiangjiana/Android-MS
(VX：mm14525201314)ide

1、EventBus簡介

EventBus是一個Android端優化的publish/subscribe消息總線，簡化了應用程序內各組件間、組件與後臺線程間的通訊。函數

做爲一個消息總線主要有三個組成部分：
事件（Event）： 能夠是任意類型的對象。經過事件的發佈者將事件進行傳遞。
事件訂閱者（Subscriber）： 接收特定的事件。
事件發佈者（Publisher）： 用於通知 Subscriber 有事件發生。能夠在任意線程任意位置發送事件。

上圖解釋了整個EventBus的大概工做流程：事件的發佈者（Publisher）將事件（Event）經過post()方法發送。EventBus內部進行處理，找到訂閱了該事件（Event）的事件訂閱者（Subscriber）。而後該事件的訂閱者（Subscriber）經過 onEvent()方法接收事件進行相關處理（關於onEvent()在EventBus 3.0中有改動，下面詳細說明）。oop

2、`EventBus`的簡單使用

一、把`EventBus`依賴到項目

build.gradle添加引用post

compile 'de.greenrobot:eventbus:3.0.0-beta1'

二、構造事件（Event）對象。也就是發送消息類每個消息類，對應一種事件。這裏咱們定義兩個消息發送類。後面講解具體做用。

public class NewsEvent { 
     private String message; 

     public NewsEvent(String message) { 
        this.message = message; 
     }

     public String getMessage() { 
        return message; 
     }
     public void setMessage(String message) { 
        this.message = message; 
     } 
  }

public class ToastEvent { 
     private String content; 

     public ToastEvent(String content) { 
        this.content = content; 
     }
     public String getContent() { 
        return content; 
     }

     public void setContent(String content) { 
        this.content = content; 
     } 
  }

三、註冊/解除事件訂閱（Subscriber）

EventBus.getDefault().register(this);//註冊事件 其中this表明訂閱者

具體註冊了對什麼事件的訂閱，這個須要onEvent()方法來講明。在EventBus 3.0之前，onEvent()方法是用來接收指定事件（Event）類型對象，而後進行相關處理操做。在EventBus 3.0以後，onEvent()方法能夠自定義方法名，不過要加入註解 @Subscribe。學習

@Subscribe 
      public void onToastEvent(ToastEvent event){ 
         Toast.makeText(MainActivity.this,event.getContent(),Toas t.LENGTH_SHORT).show();
   }

經過register(this)來表示該訂閱者進行了訂閱，經過onToastEvent(ToastEvent event)表示指定對事件ToastEvent的訂閱。到這裏訂閱就完成了。gradle

須要注意的是： 通常在onCreate()方法中進行註冊訂閱。在onDestory()方法中進行解除訂閱。優化

@Override 
      protected void onDestroy() { 
          super.onDestroy(); 
          EventBus.getDefault().unregister(this); 
  }

4 、發送消息訂閱已經完成，那麼即可以發送訂閱了。

EventBus.getDefault().post(new ToastEvent("Toast,發個提示，祝你們身體健康，勤洗手戴口罩！"));

那麼onToastEvent(ToastEvent event)會收到事件，並彈出提示。

EventBus的基礎使用流程就是這樣的。其實，EventBus還有好多其餘的功能。下面咱們一個個介紹。

3、`EventBus`的進階使用

1.線程模式`ThreadMode`

當你接收的的事件後，若是處於非UI線程，你要更新UI怎麼辦？若是處於UI線程，你要進行耗時操做，怎麼辦?等等其餘狀況，經過ThreadMode通通幫你解決。

用法展現：

@Subscribe(threadMode = ThreadMode.MainThread) 
      public void onNewsEvent(NewsEvent event){ 
         String message = event.getMessage(); 
         mTv_message.setText(message); 
  }

使用起來很簡單，經過 @Subscribe(threadMode = ThreadMode.MainThread)便可指定。下面具體介紹下ThreadMode。

關於ThreadMode，一共有四種模式PostThread，PostThread， BackgroundThread以及Async。

PostThread： 事件的處理在和事件的發送在相同的進程，因此事件處理時間不該太長，否則影響事件的發送線程。

MainThread: 事件的處理會在UI線程中執行。事件處理時間不能太長，這個不用說的，長了會ANR的。

BackgroundThread： 若是事件是在UI線程中發佈出來的，那麼事件處理就會在子線程中運行，若是事件原本就是子線程中發佈出來的，那麼事件處理直接在該子線程中執行。全部待處理事件會被加到一個隊列中，由對應線程依次處理這些事件，若是某個事件處理時間太長，會阻塞後面的事件的派發或處理。

Async： 事件處理會在單獨的線程中執行，主要用於在後臺線程中執行耗時操做，每一個事件會開啓一個線程。

2.`priority`事件優先級

事件的優先級相似廣播的優先級，優先級越高優先得到消息。用法展現：

@Subscribe(priority = 100) 
      public void onToastEvent(ToastEvent event){ 
         Toast.makeText(MainActivity.this,event.getContent(),Toas t.LENGTH_SHORT).show(); 
  }

當多個訂閱者（Subscriber）對同一種事件類型進行訂閱時，即對應的事件處理方法中接收的事件類型一致，則優先級高（priority 設置的值越大），則會先接收事件進行處理；優先級低（priority 設置的值越小），則會後接收事件進行處理。

除此以外，EventBus也能夠終止對事件繼續傳遞的功能。用法展現：

@Subscribe(priority = 100) 
      public void onToastEvent(ToastEvent event){ 
         Toast.makeText(MainActivity.this,event.getContent(),Toas t.LENGTH_SHORT).show(); 
         EventBus.getDefault().cancelEventDelivery(event);
   }

這樣其餘優先級比100低，而且訂閱了該事件的訂閱者就會接收不到該事件。

3.`EventBus`黏性事件

EventBus除了普通事件也支持粘性事件。能夠理解成：訂閱在發佈事件以後，但同樣能夠收到事件。訂閱/解除訂閱和普通事件同樣，可是處理訂閱的方法有所不一樣，須要註解中添加sticky = true。用法展現：

@Subscribe(priority = 100,sticky = true) 
      public void onToastEvent(ToastEvent event){ 
         Toast.makeText(MainActivity.this,event.getContent(),Toas t.LENGTH_SHORT).show(); 
         EventBus.getDefault().cancelEventDelivery(event); 
  }

這樣，假設一個ToastEvent 的事件已經發布，此時尚未註冊訂閱。當設置了 sticky = true，在ToastEvent 的事件發佈後，進行註冊。依然可以接收到以前發佈的事件。

不過這個時候，發佈事件的方式就改變了。

EventBus.getDefault().postSticky(new ToastEvent("Toast,發個提示， 避免去人多的地方！"));

咱們若是再也不須要該粘性事件咱們能夠移除

EventBus.getDefault().removeStickyEvent(ToastEvent.class);

或者調用移除全部粘性事件

EventBus.getDefault().removeAllStickyEvents();

4.`EventBus`配置

EventBus在2.3版本中添加了EventBuilder去配置EventBus的各方各面。
好比： 如何去構建一個在發佈事件時沒有訂閱者時保持沉默的EventBus。

EventBus eventBus = EventBus.builder() 
    .logNoSubscriberMessages(false) 
    .sendNoSubscriberEvent(false) 
    .build();

經過上述設置，當一個事件沒有訂閱者時，不會輸出log信息，也不會發布一條默認信息。

配置默認的EventBus實例，使用EventBus.getDefault()是一個簡單的方法。獲取一個單例的EventBus實例。EventBusBuilder也容許使用installDefaultEventBus方法去配置默認的EventBus實例。

注意： 不一樣的EventBus 的對象的數據是不共享的。經過一個EventBus 對象去發布事件，只有經過同一個EventBus 對象訂閱事件，才能接收該事件。因此以上使用EventBus.getDefault()得到的都是同一個實例。

4、源碼解析

註冊訂閱

EventBus.getDefault().register(this);

事件處理

@Subscribe(threadMode = ThreadMode.MainThread) 
      public void onNewsEvent(NewsEvent event){ 
         String message = event.getMessage(); 
         mTv_message.setText(message); 
  }

發佈事件

EventBus.getDefault().post(new NewsEvent("我是來自SecondActivity 的消息，你好！"));

以上是EventBus的基本使用。咱們先從getDefault提及。

`getDefault()`

static volatile EventBus defaultInstance; 
  public static EventBus getDefault() { 
         if (defaultInstance == null) { 
            synchronized (EventBus.class) { 
               if (defaultInstance == null) { 
                   defaultInstance = new EventBus(); 
               } 
            } 
         }
         return defaultInstance;
   }

經過上述代碼能夠得知，getDefault()中經過雙檢查鎖（DCL）機制實現了 EventBus的單例機制，得到了一個默認配置的EventBus對象。下面咱們繼續看 register()方法。

`register()`

在瞭解register()以前，咱們先要了解一下EventBus中的幾個關鍵的成員變量。方便對下面內容的理解。

/** Map<訂閱事件, 訂閱該事件的訂閱者集合> 
  */ 
   private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType; 

  /** Map<訂閱者, 訂閱事件集合> 
  */ 
   private final Map<Object, List<Class<?>>> typesBySubscriber; 

  /** Map<訂閱事件類類型,訂閱事件實例對象>. 
  */ 
   private final Map<Class<?>, Object> stickyEvents;

下面看具體的register()中執行的代碼。

public void register(Object subscriber) { 
         //訂閱者類型 
         Class<?> subscriberClass = subscriber.getClass(); 
         //判斷該類是否是匿名類，若是是匿名累要使用反射 
         boolean forceReflection = subscriberClass.isAnonymousCla ss(); 
         //獲取訂閱者所有的響應函數信息（即上面的onNewsEvent()之類的方法） 
         List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(sub scriberClass, forceReflection); 
        //循環每個事件響應函數，執行 subscribe()方法，更新訂閱相關信息 
        for (SubscriberMethod subscriberMethod : subscriberMetho ds) { subscribe(subscriber, subscriberMethod); 
        } 
  }

因而可知，register()
第一步 獲取訂閱者的類類型.
第二步 經過 SubscriberMethodFinder類來解析訂閱者類,獲取全部的響應函數集合.
第三步 遍歷訂閱函數,執行 subscribe()方法，更新訂閱相關信息。關於 subscriberMethodFinder這裏就不介紹了。先跟着線索，繼續看subscribe()方法。subscribe函數分三步。

第一步：

//獲取訂閱的事件類型 
    Class<?> eventType = subscriberMethod.eventType; 
    //獲取訂閱該事件的訂閱者集合 
    CopyOnWriteArrayList<Subscription> subscriptions = subsc riptionsByEventType.get(eventType); 
    //把經過register()訂閱的訂閱者包裝成Subscription 對象 Subscription newSubscription = new Subscription(subscrib er, subscriberMethod); 
    //訂閱者集合爲空，建立新的集合，並把newSubscription 加入
    if (subscriptions == null) { 
        subscriptions = new CopyOnWriteArrayList<Subscriptio n>(); 

        subscriptionsByEventType.put(eventType, subscription s); 

    } else { 
        //集合中已經有該訂閱者，拋出異常。不能重複訂閱 
        if (subscriptions.contains(newSubscription)) { 
            throw new EventBusException("Subscriber " + subs criber.getClass() + " already registered to event " + eventType); 
        } 
    }
    //把新的訂閱者按照優先級加入到訂閱者集合中。 
    synchronized (subscriptions) { 
        int size = subscriptions.size(); 
        for (int i = 0; i <= size; i++) { 
            if (i == size || subscriberMethod.priority > sub scriptions.get(i).subscriberMethod.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);

第三步：

//該事件是stick=true。 
  if (subscriberMethod.sticky) { 
           //響應訂閱事件的父類事件 
           if (eventInheritance) { 
               Set<Map.Entry<Class<?>, Object>> entries = stick yEvents.entrySet(); 
               //循環得到每一個stickyEvent事件 
               for (Map.Entry<Class<?>, Object> entry : entries ) { 
                    Class<?> candidateEventType = entry.getKey() ; 

                   //是該類的父類 
                   if (eventType.isAssignableFrom(candidateEven tType)) { 
                      //該事件類型最新的事件發送給當前訂閱者。 
                      Object stickyEvent = entry.getValue(); 
                      checkPostStickyEventToSubscription(newSu bscription, stickyEvent); 
                   } 
              } 
          } else { 
             Object stickyEvent = stickyEvents.get(eventType) ; 
             checkPostStickyEventToSubscription(newSubscripti on, stickyEvent); 
          } 
  }

因而可知，
第一步： 經過subscriptionsByEventType獲得該事件類型全部訂閱者信息隊列，根據優先級將當前訂閱者信息插入到訂閱者隊列 subscriptionsByEventType中；
第二步： 在typesBySubscriber中獲得當前訂閱者訂閱的全部事件隊列，將此事件保存到隊列typesBySubscriber中，用於後續取消訂閱；
第三步： 檢查這個事件是否是 Sticky 事件，若是是則從stickyEvents事件保存隊列中取出該事件類型最後一個事件發送給當前訂閱者。

到此，便完成了訂閱功能。下面是訂閱的具體流程圖：

`unregister()`

public synchronized void unregister(Object subscriber) { 
     // 獲取該訂閱者全部的訂閱事件類類型集合. 
     List<Class<?>> subscribedTypes = typesBySubscriber.get(subsc riber); 
     if (subscribedTypes != null) { 
         for (Class<?> eventType : subscribedTypes) { 
              unsubscribeByEventType(subscriber, eventType); 
         }
         // 從typesBySubscriber刪除該<訂閱者對象,訂閱事件類類型集合> 
         typesBySubscriber.remove(subscriber); 
     } else { 
         Log.e("EventBus", "Subscriber to unregister was not regi stered before: "+ subscriber.getClass()); 
     } 
  }

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 --; 
              } 
         } 
     } 
  }

unregister()方法比較簡單，主要完成了subscriptionsByEventType以及 typesBySubscriber兩個集合的同步。

`post()`

public void post(Object event) { 
     // 獲取當前線程的Posting狀態. 
     PostingThreadState postingState = currentPostingThreadState. get();
     // 獲取當前線程的事件隊列.
     List<Object> eventQueue = postingState.eventQueue; 
     //將當前事件添加到其事件隊列 
     eventQueue.add(event); 
     //判斷新加入的事件是否在分發中 
     if (!postingState.isPosting) { 
          postingState.isMainThread = Looper.getMainLooper() == Lo oper.myLooper(); 
          postingState.isPosting = true; 
          if (postingState.canceled) { 
              throw new EventBusException("Internal error. Abort s tate was not reset"); 
          }try {
              // 循環處理當前線程eventQueue中的每個event對象. 
              while (!eventQueue.isEmpty()) { 
                     postSingleEvent(eventQueue.remove(0), postingSta te); 
              } 
          } finally { 
             // 處理完知乎重置postingState一些標識信息. 
             postingState.isPosting = false; 
             postingState.isMainThread = false;
         }
     } 
  }

post 函數會首先獲得當前線程的 post 信息PostingThreadState，其中包含事件隊列，將當前事件添加到其事件隊列中，而後循環調用 postSingleEvent函數發佈隊列中的每一個事件。

private void postSingleEvent(Object event, PostingThreadState po stingState) { 
     //分發事件的類型 
     Class<?> eventClass = event.getClass(); 
     boolean subscriptionFound = false; 
     //響應訂閱事件的父類事件 
     if (eventInheritance) { 
        //找出當前訂閱事件類類型eventClass的全部父類的類類型和其實現的接 口的類類型
        List<Class<?>> eventTypes = lookupAllEventTypes(eventCla ss); 
        int countTypes = eventTypes.size(); 
        for (int h = 0; h < countTypes; h ++) { 
             Class<?> clazz = eventTypes.get(h); 
             //發佈每一個事件到每一個訂閱者 
             subscriptionFound |= postSingleEventForEventType(eve nt, postingState, clazz); 
        } 
     } else { 
        subscriptionFound = postSingleEventForEventType(event, p ostingState, eventClass); 
     }
      .................................... 
  }

調用 postSingleEventForEventType 函數發佈每一個事件到每一個訂閱者

private boolean postSingleEventForEventType(Object event, Postin gThreadState postingState, Class<?> eventClass) { 
     CopyOnWriteArrayList<Subscription> subscriptions; 
     synchronized (this) { 
         // 獲取訂閱事件類類型對應的訂閱者信息集合.(register函數時構造的集 合) 
         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, postingS tate.isMainThread); 
                  aborted = postingState.canceled; 
              } finally {
                  postingState.event = null; 
                  postingState.subscription = null; 
                  postingState.canceled = false; 
             }
             if (aborted) { 
                  break; 
             } 
         }
         return true;
     }
     return false;
   }

調用 postToSubscription 函數向每一個訂閱者發佈事件。 postToSubscription 函數中會判斷訂閱者的 ThreadMode，從而決定在什麼 Mode 下執行事件響應函數。這裏就不貼源碼了。後續還牽着到反射以及線程調度問題，這裏就不展開了。以上就是 post的流程，下面是具體的post的流程圖。

上圖知識彙總的PDF相關內容後續GitHub更新,想衝擊金三銀四的小夥伴能夠找找看看，歡迎star
（順手留下GitHub連接，須要獲取相關面試等內容的能夠本身去找）
https://github.com/xiangjiana/Android-MS
(VX：mm14525201314)