Android开源框架—EventBus

心已赠人 2022-09-10 11:07 240阅读 0赞

1.EventBus框架  
EventBus，即事件总线，一款针对Android优化的发布/订阅事件总线，主要功能是替代Intent,Handler,BroadCast在Fragment、Activity、Service、线程之间传递消息。  
它是一个基于观察者模式的事件发布/订阅框架，开发者可以通过极少的代码去实现多个模块之间的通信，而不需要以层层传递接口的形式去单独构建通信桥梁。从而降低因多重回调导致的模块间强耦合，同时避免产生大量内部类。  
如下图所示即EventBus的运行框架。  
![EventBus运行框架][EventBus]  
EventBus主要用于同一进程间通信，支持多线程通信。（跨进程通信可以用广播）

2.EventBus使用了发布者/订阅者模式。  
在EventBus中主要有以下三个成员：  
①Event：事件，可以自定义为任意对象，类似Message类的作用；  
②Publisher：事件发布者，可以在任意线程、任意位置发布Event，已发布的Event则由EventBus进行分发；  
③Subscriber：事件订阅者，接收并处理事件，需要通过register(this)进行注册，而在类销毁时要使用unregister(this)方法解注册。每个Subscriber可以定义一个或多个事件处理方法，其方法名可以自定义，但需要添加@Subscribe的注解，并指明ThreadMode（不写默认为Posting）。  
发布者通过EventBus发布事件，订阅者通过EventBus订阅事件。当发布者发布事件时，订阅该事件的订阅者的事件处理方法将被调用。  
注意：订阅者可以订阅多个事件，发布者可以发布任何事件，发布者同时也可以是订阅者。

3.EventBus使用流程  
要使用EventBus，首先需要在build.gradle 中添加EventBus的依赖：  
dependencies \{  
…  
compile ‘org.greenrobot:eventbus:3.1.1’  
\}  
接下来开始使用EventBus，主要分为3个步骤：定义事件、订阅事件、发布事件。  
①定义事件。事件可以是任意普通的Java对象，没有任何特殊的要求。  
public class MessageEvent \{  
private String message;  
public MessageEvent(String message) \{  
this.message = message;  
\}  
public String getMessage() \{  
return message;  
\}  
public void setMessage(String message) \{  
this.message = message;  
\}  
\}  
②订阅事件。订阅者需要定义事件处理方法（也称为订阅者方法）。当发布对应类型的事件时，该方法将被调用。  
在EventBus2.x的时候，订阅者方法都是固定函数名，而EventBus3以后使用 @Subscribe 注解来定义订阅者方法，方法名可以是任意合法的方法名，参数类型为订阅事件的类型。  
@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) \{  
…  
\}  
订阅者还需要在总线上注册，并在不需要时在总线上注销。只有订阅者注册了，它们才会收到事件。在Android中，可以根据Activity或者Fragment的生命周期来注册和注销。  
@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_main);  
initContentView();  
// 注册订阅者  
EventBus.getDefault().register(this);  
\}

@Override  
protected void onDestroy() \{  
super.onDestroy();  
// 注销订阅者  
EventBus.getDefault().unregister(this);  
\}  
③发布事件。在需要的地方发布事件，所有订阅了该类型事件并已注册的订阅者将收到该事件。  
// 发布事件  
EventBus.getDefault().post(new MessageEvent(“Hello EventBus!”));

4.实例  
下面是一个EventBus的例子。  
订阅事件的代码：  
public class MainActivity extends AppCompatActivity implements View.OnClickListener \{  
private static final String TAG = “MainActivity”;  
private TextView mTvMessage;

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_main);  
initContentView();  
// 注册订阅者  
EventBus.getDefault().register(this);  
\}

private void initContentView() \{  
Button btnStart = findViewById(R.id.btn\_main\_start\_activity);  
mTvMessage = findViewById(R.id.tv\_main\_message);  
btnStart.setOnClickListener(this);  
\}

@Override  
public void onClick(View v) \{  
if (v.getId() == R.id.btn\_main\_start\_activity) \{  
Intent intent = new Intent(this, SecondActivity.class);  
context.startActivity(intent);  
\}  
\}

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) \{  
Log.i(TAG, "message is " + event.getMessage());  
// 更新界面  
mTvMessage.setText(event.getMessage());  
\}

@Override  
protected void onDestroy() \{  
super.onDestroy();  
// 注销订阅者  
EventBus.getDefault().unregister(this);  
\}  
｝  
MainActivity订阅了MessageEvent事件。当接收到MessageEvent事件时，订阅者方法将打印日志消息，并更新界面上的TextView。

发布事件的代码：  
public class SecondActivity extends AppCompatActivity implements View.OnClickListener \{

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_second);  
initContentView();  
\}

private void initContentView() \{ findViewById(R.id.btn\_second\_post\_event).setOnClickListener(this);  
\}

@Override  
public void onClick(View v) \{  
if (v.getId() == R.id.btn\_second\_post\_event) \{  
// 发布事件  
EventBus.getDefault().post(new MessageEvent(“Hello EventBus!”));  
\}  
\}  
\}  
当点击发布事件的按钮时，SecondActivity将发布一个MessageEvent事件。

运行应用。点击MainActivity界面上的启动活动按钮来启动SecondActivity，然后点击SecondActivity界面上的发布事件按钮来发布事件。最后，回退到MainActivity，可以看到界面上的TextView的内容已经更新为”Hello EventBus!”，并且应用打印出如下信息：  
message is Hello EventBus!

5.线程模式  
EventBus支持订阅者方法在不同于发布事件所在线程的线程中被调用。你可以使用线程模式来指定调用订阅者方法的线程。  
EventBus总共支持5种线程模式：  
①ThreadMode.POSTING  
订阅者方法将在发布事件所在的线程中被调用。这是 默认的线程模式。事件的传递是同步的，一旦发布事件，所有该模式的订阅者方法都将被调用。这种线程模式意味着最少的性能开销，因为它避免了线程的切换。因此，对于不要求是主线程并且耗时很短的简单任务推荐使用该模式。使用该模式的订阅者方法应该快速返回，以避免阻塞发布事件的线程，这可能是主线程。  
②ThreadMode.MAIN  
订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。如果发布事件的线程是主线程，那么该模式的订阅者方法将被直接调用。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。  
③ThreadMode.MAIN\_ORDERED  
订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。事件将先进入队列然后才发送给订阅者，这使得事件的处理保持严格的串行顺序。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。  
④ThreadMode.BACKGROUND  
订阅者方法将在后台线程中被调用。如果发布事件的线程不是主线程，那么订阅者方法将直接在该线程中被调用。如果发布事件的线程是主线程，那么将使用一个单独的后台线程，该线程将按顺序发送所有的事件。使用该模式的订阅者方法应该快速返回，以避免阻塞后台线程。  
⑤ThreadMode.ASYNC  
订阅者方法将在一个单独的线程中被调用，因此，发布事件的调用将立即返回。如果订阅者方法的执行需要一些时间，例如网络访问，那么就应该使用该模式。避免触发大量的长时间运行的订阅者方法，以限制并发线程的数量。EventBus使用了一个线程池来有效地重用已经完成调用订阅者方法的线程。  
下面是一个例子，来说明这五种线程模式的区别。  
public class EventBusActivity extends AppCompatActivity \{  
private TextView tv\_Event;  
@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_event\_bus);  
//注册事件  
EventBus.getDefault().register(this);  
Thread thread1 = new Thread(new myThread1());  
thread1.start();  
\}

//事件处理方法  
@Subscribe(threadMode = ThreadMode.MAIN)  
public void onEventMain(myEvent me)\{  
Log.d(TAG,me.getmessage() + " onEventMain" + " thread:" + android.os.Process.myTid());  
\}

//事件处理方法  
@Subscribe(threadMode=ThreadMode.MAIN\_ORDERED)  
public void onEventMainOrdered(myEvent me)\{  
Log.d(TAG,me.getmessage() + " onEventMainOrdered" + " thread:" + android.os.Process.myTid());  
\}

//事件处理方法  
@Subscribe(threadMode=ThreadMode.POSTING)  
public void onEventPosting(myEvent te)\{  
Log.d(TAG,te.getmessage() + " onEventPosting" + " thread:" + android.os.Process.myTid());  
\}

//事件处理方法  
@Subscribe(threadMode=ThreadMode.BACKGROUND)  
public void onEventBackground(myEvent me)\{  
Log.d(TAG,me.getmessage() + " onEventBackground" + " thread:" + android.os.Process.myTid());  
\}

//事件处理方法  
@Subscribe(threadMode=ThreadMode.ASYNC)  
public void onEventAsync(myEvent me)\{  
Log.d(TAG,me.getmessage() + " onEventAsync" + " thread:" + android.os.Process.myTid());  
\}

@Override  
protected void onDestroy() \{  
super.onDestroy();  
//解注册  
EventBus.getDefault().unregister(this);  
\}

public class myThread1 implements Runnable \{

@Override  
public void run() \{  
Log.d(TAG,"" + android.os.Process.myTid());  
try \{  
Thread.sleep(1000);  
//事件发布  
EventBus.getDefault().post(new myEvent(“this is first message !”));  
\} catch (InterruptedException e) \{  
e.printStackTrace();  
\}  
\}  
\}  
\}  
执行结果如下：  
05-24 17:17:47.335 24447 24478 D EventBusActivity: 24478  
05-24 17:17:48.341 24447 24478 D EventBusActivity: this is first message ! onEventBackground thread:24478  
05-24 17:17:48.341 24447 24498 D EventBusActivity: this is first message ! onEventAsync thread:24498  
05-24 17:17:48.342 24447 24447 D EventBusActivity: this is first message ! onEventMain thread:24447  
05-24 17:17:48.342 24447 24447 D EventBusActivity: this is first message ! onEventMainOrdered thread:24447  
05-24 17:17:48.344 24447 24478 D EventBusActivity: this is first message ! onEventPosting thread:24478  
  主线程Tid为24447，子线程Tid为24478，可以看到每种ThreadMode的运行方式。  
  另外我们可以通过定义不同的事件类作为post的参数来执行不同的事件执行方法。  
    
6.EventBus的粘性事件  
  以上的Demo中，事件订阅者的注册必须在发布事件之前，否则发布之后，订阅者无法接受到事件，而粘性事件则避免了这一问题。  
  如果先发布了事件，然后有订阅者订阅了该事件，那么除非再次发布该事件，否则订阅者将永远接收不到该事件。此时，可以使用粘性事件。发布一个粘性事件之后，EventBus将在内存中缓存该粘性事件。当有订阅者订阅了该粘性事件，订阅者将接收到该事件。  
  粘性事件的发布使用postSticky()方法即可，并在注解中配置sticky参数。  
    
// 订阅粘性事件  
@Subscribe(sticky = true)  
public void onMessageEvent(MessageEvent event) \{  
…  
\}

// 发布粘性事件  
EventBus.getDefault().postSticky(new MessageEvent(“Hello EventBus!”));

发布一个粘性事件之后，EventBus将一直缓存该粘性事件。如果想要移除粘性事件，那么可以使用如下方法：  
// 移除指定的粘性事件  
removeStickyEvent(Object event);  
// 移除指定类型的粘性事件  
removeStickyEvent(Class eventType);  
// 移除所有的粘性事件  
removeAllStickyEvents();

下面是一个粘性事件的例子。  
发布粘性事件的代码如下所示：  
public class MainActivity extends AppCompatActivity implements View.OnClickListener \{

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_main);  
initContentView();  
\}

private void initContentView() \{  
findViewById(R.id.btn\_main\_post\_event).setOnClickListener(this);  
findViewById(R.id.btn\_main\_start\_activity).setOnClickListener(this);  
\}

@Override  
public void onClick(View v) \{  
switch (v.getId()) \{  
case R.id.btn\_main\_post\_event:  
// 发布粘性事件  
EventBus.getDefault().postSticky(new MessageEvent(“Hello EventBus!”));  
break;  
case R.id.btn\_main\_start\_activity:  
Intent intent = new Intent(this, SecondActivity.class);  
context.startActivity(intent);  
break;  
default:  
break;  
\}  
\}  
\}  
当点击发布粘性事件的按钮时，MainActivity将发布一个MessageEvent粘性事件。  
订阅粘性事件的代码如下所示：  
public class SecondActivity extends AppCompatActivity \{  
private static final String TAG = “SecondActivity”;  
private TextView mTvMessage;

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_second);  
initContentView();  
// 注册订阅者  
EventBus.getDefault().register(this);  
\}

private void initContentView() \{  
mTvMessage = findViewById(R.id.tv\_second\_message);  
\}

@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)  
public void onMessageEvent(MessageEvent event) \{  
Log.i(TAG, "message is " + event.getMessage());  
// 更新界面  
mTvMessage.setText(event.getMessage());  
// 移除粘性事件 EventBus.getDefault().removeStickyEvent(event);  
\}

@Override  
protected void onDestroy() \{  
super.onDestroy();  
// 注销订阅者  
EventBus.getDefault().unregister(this);  
\}  
\}  
SecondActivity订阅了MessageEvent粘性事件。当接收到MessageEvent粘性事件时，订阅者方法将打印日志消息，并更新界面上的TextView，最后移除该粘性事件。

运行应用。先点击MainActivity界面上的发布粘性事件按钮来发布粘性事件，然后点击启动活动按钮来启动SecondActivity。可以看到SecondActivity界面上的TextView的内容更新为”Hello EventBus!”，并且应用打印出如下信息：  
message is Hello EventBus!

7.事件优先级  
EventBus支持在定义订阅者方法时指定事件传递的优先级。默认情况下，订阅者方法的事件传递优先级为0。数值越大，优先级越高。在相同的线程模式下，更高优先级的订阅者方法将优先接收到事件。  
注意：优先级只有在相同的线程模式下才有效。

指定事件传递优先级的示例代码如下所示：  
@Subscribe(priority = 1)  
public void onMessageEvent(MessageEvent event) \{  
…  
\}

你可以在高优先级的订阅者方法接收到事件之后取消事件的传递。此时，低优先级的订阅者方法将不会接收到该事件。  
注意： 订阅者方法只有在线程模式为ThreadMode.POSTING时，才可以取消一个事件的传递。

取消事件传递的示例代码如下所示：  
@Subscribe(threadMode = ThreadMode.POSTING, priority = 1)  
public void onMessageEvent(MessageEvent event) \{  
…  
// 取消事件传递  
EventBus.getDefault().cancelEventDelivery(event);  
\}

下面是一个例子。  
订阅事件的代码:  
public class MainActivity extends AppCompatActivity implements View.OnClickListener \{  
private static final String TAG = “MainActivity”;

private void initContentView() \{  
findViewById(R.id.btn\_main\_start\_activity).setOnClickListener(this);  
\}

@Override  
public void onClick(View v) \{  
if (v.getId() == R.id.btn\_main\_start\_activity) \{  
Intent intent = new Intent(this, SecondActivity.class);  
context.startActivity(intent);  
\}  
\}

@Subscribe(threadMode = ThreadMode.POSTING, priority = 1)  
public void onMessageEvent1(MessageEvent event) \{  
Log.i(TAG, "onMessageEvent1(), message is " + event.getMessage());  
\}

@Subscribe(threadMode = ThreadMode.POSTING, priority = 2)  
public void onMessageEvent2(MessageEvent event) \{  
Log.i(TAG, "onMessageEvent2(), message is " + event.getMessage());  
// 取消事件  
EventBus.getDefault().cancelEventDelivery(event);  
\}

@Subscribe(threadMode = ThreadMode.POSTING, priority = 3)  
public void onMessageEvent3(MessageEvent event) \{  
Log.i(TAG, "onMessageEvent3(), message is " + event.getMessage());  
\}

@Subscribe(threadMode = ThreadMode.POSTING, priority = 4)  
public void onMessageEvent4(MessageEvent event) \{  
Log.i(TAG, "onMessageEvent4(), message is " + event.getMessage());  
\}

@Subscribe(threadMode = ThreadMode.POSTING, priority = 5)  
public void onMessageEvent5(MessageEvent event) \{  
Log.i(TAG, "onMessageEvent5(), message is " + event.getMessage());  
\}

@Override  
protected void onDestroy() \{  
super.onDestroy();  
// 注销订阅者  
EventBus.getDefault().unregister(this);  
\}  
\}  
MainActivity订阅了MessageEvent事件，定义了5个不同优先级的订阅者方法。当接收到MessageEvent事件时，订阅者方法将打印日志消息。优先级为2的订阅者方法在接收到事件之后取消了事件的传递。

发布事件的代码如下所示：  
public class SecondActivity extends AppCompatActivity implements View.OnClickListener \{

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_second);  
initContentView();  
\}

private void initContentView() \{  
findViewById(R.id.btn\_second\_post\_event).setOnClickListener(this);  
\}

运行应用。点击MainActivity界面上的启动活动按钮来启动SecondActivity，然后点击SecondActivity界面上的发布事件按钮来发布事件。应用打印出如下信息：  
onMessageEvent5(), message is Hello EventBus!  
onMessageEvent4(), message is Hello EventBus!  
onMessageEvent3(), message is Hello EventBus!  
onMessageEvent2(), message is Hello EventBus!  
可见，优先级为2的订阅者方法在接收到事件之后取消了事件的传递，因此优先级为1的订阅者方法接收不到事件了。

8.EventBus3源码解析  
a.注册源码解析  
我们写EventBus都是从rigister开始，我们就从EventBus.getDefault().register(this);入手，首先查看EventBus.getDefault()，看看EventBus是如何初始化的：  
public static EventBus getDefault() \{  
if (defaultInstance ==null) \{  
synchronized (EventBus.class) \{  
if (defaultInstance ==null) \{  
defaultInstance = new EventBus();  
\}  
\}  
\}  
return defaultInstance;  
\}  
可以看出来，EventBus是单例模式存在的，一个项目中只能有一个EventBus这样有利于管理订阅者和订阅方法。  
接下来看register(this)：  
public void register(Object subscriber) \{  
//订阅者  
Class<?> subscriberClass = subscriber.getClass();  
List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);  
synchronized (this) \{  
for (SubscriberMethod subscriberMethod : subscriberMethods) \{  
subscribe(subscriber, subscriberMethod);  
\}  
\}  
\}  
可以看出首先获取订阅者的类对象Class<?> subscriberClass = subscriber.getClass(); 在看这段代码之前，我们首先要了解SubscriberMethod和subscriberMethodFinder.findSubscriberMethods方法到底做了什么。  
首先来看SubscriberMethod：  
public class SubscriberMethod \{  
final Method method;//方法  
final ThreadMode threadMode;//执行线程  
final Class<?> eventType;//接收的事件类型  
final int priority;//优先级  
final boolean sticky;  
/\*\* Used for efficient comparison \*/  
String methodString;  
…  
\}  
可以看出SubscriberMethod其实就是一个订阅方法的实体类，里面保存了订阅方法信息。  
接着看subscriberMethodFinder.findSubscriberMethods，该方法的作用其实就是从订阅类中获取所有的订阅方法信息：  
List findSubscriberMethods(Class<?> subscriberClass) \{  
//首先从缓存中读取  
List subscriberMethods = METHOD\_CACHE.get(subscriberClass);  
if (subscriberMethods != null) \{  
return subscriberMethods;  
\}  
//是否忽略注解器生成的MyEventBusIndex类  
if (ignoreGeneratedIndex) \{  
//利用反射来获取订阅类中的订阅方法信息  
subscriberMethods = findUsingReflection(subscriberClass);  
\} else \{  
//从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息  
subscriberMethods = findUsingInfo(subscriberClass);  
\}  
if (subscriberMethods.isEmpty()) \{  
throw new EventBusException(“Subscriber " + subscriberClass + " and its super classes have no public methods with the @Subscribe annotation”);  
\} else \{  
//保存进缓存  
METHOD\_CACHE.put(subscriberClass, subscriberMethods);  
return subscriberMethods;  
\}  
\}  
我们看到，该方法首先从缓存中获取订阅类的订阅方法信息，如果没有则通过两种方式来获取：  
1、通过EventBusAnnotationProcessor（注解处理器）生成的MyEventBusIndex中获取。  
2、利用反射来读取订阅类中订阅方法信息。  
在3.0版本中,EventBus提供了一个EventBusAnnotationProcessor注解处理器来在编译期通过读取@Subscribe()注解并解析, 处理其中所包含的信息, 然后生成java类来保存所有订阅者关于订阅的信息, 这样就比在运行时使用反射来获得这些订阅者的信息速度要快。  
接下来我们重点研究一下通过反射来获取订阅方法信息即：findUsingReflection(subscriberClass)方法。  
private List findUsingReflection(Class<?> subscriberClass) \{  
FindState findState = prepareFindState();  
findState.initForSubscriber(subscriberClass);  
while (findState.clazz != null) \{ findUsingReflectionInSingleClass(findState);  
findState.moveToSuperclass();  
\}  
return getMethodsAndRelease(findState);  
\}  
FindState其实就是一个里面保存了订阅者和订阅方法信息的一个实体类，包括订阅类中所有订阅的事件类型和所有的订阅方法等。我们看到会首先创建一个FindState对象并执行findUsingReflectionInSingleClass(findState);来获取订阅类的方法信息：  
private void findUsingReflectionInSingleClass(FindState findState) \{  
Method\[\] methods;  
try \{ methods=findState.clazz.getDeclaredMethods();  
\} catch (Throwable th) \{  
//通过反射获取到订阅类中的所有方法  
methods = findState.clazz.getMethods();  
findState.skipSuperClasses = true;  
\}  
//遍历所有方法，忽略private类型的，最后如果是公有，并且不是 java编译器 生成的方法名，那么就是我们要的了。  
for (Method method : methods) \{  
int modifiers = method.getModifiers();  
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS\_IGNORE) ==0) \{  
Class<?>\[\] parameterTypes=method.getParameterTypes();  
//保证只有一个事件参数  
if (parameterTypes.length ==1) \{  
//得到注解  
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);  
if (subscribeAnnotation != null) \{  
Class<?> eventType = parameterTypes\[0\];  
//校验是否添加该方法  
if (findState.checkAdd(method, eventType)) \{  
ThreadMode threadMode = subscribeAnnotation.threadMode();  
//添加方法 findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode, subscribeAnnotation.priority(), subscribeAnnotation.sticky()));  
\}  
\}  
\} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) \{  
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)) \{  
String methodName = method.getDeclaringClass().getName() + “.” + method.getName();  
throw new EventBusException(methodName + " is a illegal @Subscribe method: must be public, non-static, and non-abstract”);  
\}  
\}  
\}  
可以看到，首先会得到订阅类的class对象并通过反射获取订阅类中的所有方法信息，然后通过筛选获取到订阅方法集合。  
程序执行到此我们就获取到了订阅类中的所有的订阅方法信息，接下来我们就要对订阅方法进行注册：subscribe(subscriber, subscriberMethod);//参数：1订阅者2订阅方法集

// Must be called in synchronized block  
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) \{  
//获取订阅方法的参数类型  
Class<?> eventType = subscriberMethod.eventType;  
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);  
//根据订阅的事件类型获取所有的订阅者  
CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);  
//将订阅者添加到subscriptionsByEventType集合中  
if (subscriptions ==null) \{  
subscriptions = new CopyOnWriteArrayList<>();  
subscriptionsByEventType.put(eventType, subscriptions);  
\} else \{  
if (subscriptions.contains(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 || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) \{  
subscriptions.add(i, newSubscription);  
break;  
\}  
\}  
//获取订阅者所有订阅的事件类型  
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);  
if (subscribedEvents ==null) \{  
subscribedEvents = new ArrayList<>();  
typesBySubscriber.put(subscriber, subscribedEvents);  
\}  
//将该事件类型添加到typesBySubscriber中  
subscribedEvents.add(eventType);

//如果接收sticky事件,立即分发sticky事件  
if (subscriberMethod.sticky) \{  
if (eventInheritance) \{  
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();  
checkPostStickyEventToSubscription(newSubscription, stickyEvent);  
\}  
\}  
\} else \{  
Object stickyEvent = stickyEvents.get(eventType);  
checkPostStickyEventToSubscription(newSubscription, stickyEvent);  
\}  
\}  
\}  
上面这段代码涉及到几个对象：  
①Subscription //订阅者信息  
final class Subscription \{  
final Object subscriber;//订阅者  
final SubscriberMethod subscriberMethod;//订阅方法  
\}  
②subscriptionsByEventType  
key订阅方法类型，values 所有订阅了该类型的订阅者集合  
Map<\\Class<?>,CopyOnWriteArrayList<\\Subscription>> subscriptionsByEventType;  
③typesBySubscriber  
key订阅者，values订阅事件集合  
Map<\\Object, List<\\Class<?>>> typesBySubscriber;  
了解了这几个对象，上面的代码就很容易看懂了：  
1、首先获取订阅方法的参数类型即订阅事件类型  
2、根据订阅事件类型获取该事件类型的所有订阅者  
3、将该订阅者添加到该事件类型的订阅者集合中即：subscriptionsByEventType  
4、获取订阅者所有的订阅事件类型  
5、将该事件类型添加到该订阅者的订阅事件类型集中即:typesBySubscriber  
至此，就完成了订阅类中订阅方法的注册，我们来看一下整个流程：  
![register流程][register]

b.事件发布源码解析  
接下来我们来分析EventBus的事件发布机制即EventBus.getDefault().post(“…”);  
我们从post方法入手：  
/\*\* Posts the given event to the event bus. \*/  
public void post(Object event) \{  
//获取当前线程的postingState  
PostingThreadState postingState = currentPostingThreadState.get();  
//取得当前线程的事件队列  
List eventQueue = postingState.eventQueue;  
//将该事件添加到当前的事件队列中等待分发  
eventQueue.add(event);

if (!postingState.isPosting) \{  
//判断是否是在主线程post  
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;  
\}  
\}  
\}  
什么是PostingThreadState？  
final static class PostingThreadState \{  
final List eventQueue = new ArrayList();//当前线程的事件队列  
boolean isPosting;//是否有事件正在分发  
boolean isMainThread;//post的线程是否是主线程  
Subscription subscription;//订阅者  
Object event;//订阅事件  
boolean canceled;//是否取消  
\}  
PostingThreadState中包含了当前线程的事件队列，就是当前线程所有分发的事件都保存在eventQueue事件队列中，以及订阅者订阅事件等信息，有了这些信息我们就可以从事件队列中取出事件分发给对应的订阅者。

PostingThreadState怎么获得？  
//ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，而这段数据是不会与其他线程共享的。  
private final ThreadLocal currentPostingThreadState = new ThreadLocal() \{  
@Override  
protected PostingThreadState initialValue() \{  
return new PostingThreadState();  
\}  
\};  
可以看出currentPostingThreadState的实现是一个包含了PostingThreadState的ThreadLocal对象,这样可以保证取到的都是自己线程对应的数据。  
我们有了PostingThreadState获取到了当前线程的事件队列，接下来就是事件分发，我们来看postSingleEvent(eventQueue.remove(0), postingState)方法：  
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error \{  
//得到事件类型  
Class<?> eventClass = event.getClass();  
boolean subscriptionFound = false;

//是否触发订阅了该事件(eventClass)的父类,以及接口的类的响应方法.  
if (eventInheritance) \{  
List<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));  
\}  
\}  
\}  
通过以上代码我们可以发现，真正的事件分发是通过postSingleEventForEventType(event, postingState, eventClass);发出去的我们来看：  
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) \{  
CopyOnWriteArrayList 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(subscription, event, postingState.isMainThread);发送出去。  
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) \{  
switch (subscription.subscriberMethod.threadMode) \{  
case POSTING://默认的 ThreadMode，表示在执行 Post 操作的线程直接调用订阅者的事件响应方法，  
//不论该线程是否为主线程（UI 线程）。  
invokeSubscriber(subscription, event);  
break;  
case MAIN://在主线程中执行响应方法。  
if (isMainThread) \{  
invokeSubscriber(subscription, event);  
\} else \{  
mainThreadPoster.enqueue(subscription, event);  
\}  
break;  
case BACKGROUND://在后台线程中执行响应方法。  
if (isMainThread) \{  
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的线程模式threadMode，通过以下代码我们来看一下订阅方法最后是通过invokeSubscriber(subscription, event);来执行的。  
//最终通过反射调用订阅者的订阅函数 并把event作为参数传入  
void invokeSubscriber(Subscription subscription, Object event) \{  
try \{  
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);  
\} catch (InvocationTargetException e) \{  
handleSubscriberException(subscription, event, e.getCause());  
\} catch (IllegalAccessException e) \{  
throw new IllegalStateException(“Unexpected exception”, e);  
\}  
\}  
真相大白；最后是通过反射的方式，调用了订阅类中的订阅方法。  
我们来总结一下整个事件分发的过程  
1、首先获取当前线程的PostingThreadState对象从而获取到当前线程的事件队列  
2、通过事件类型获取到所有订阅者集合  
3、通过反射执行订阅者中的订阅方法  
是不是很简单。我们来看一下整个事件分发的流程图  
![EventBus事件分发流程][EventBus 1]  
c.取消注册源码解析  
我们简单看一下取消注册的源码EventBus.getDefault().unregister(this)方法。  
/\*\* Unregisters the given subscriber from all event classes. \*/  
public synchronized void unregister(Object subscriber) \{  
//获取订阅者的所有订阅的事件类型  
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);  
if (subscribedTypes != null) \{  
for (Class<?> eventType : subscribedTypes) \{  
//从事件类型的订阅者集合中移除订阅者  
unsubscribeByEventType(subscriber, eventType);  
\}  
typesBySubscriber.remove(subscriber);  
\} else \{  
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());  
\}  
\}  
再来看一下：unsubscribeByEventType(subscriber, eventType)方法：  
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) \{  
//获取事件类型的所有订阅者  
List 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–;  
\}  
\}  
\}  
\}  
总结一下：  
1、首先获取订阅者的所有订阅事件  
2、遍历订阅事件  
3、根据订阅事件获取所有的订阅了该事件的订阅者集合  
4、将该订阅者移除  
5、将步骤1中的集合中的订阅者移除  
这样就完成了取消订阅的全过程。

[EventBus]: /images/20220829/44a1bc5e1cb0476b85210d2c0dabec2d.png
[register]: /images/20220829/44398ec241c64d56b482a105812b90ed.png
[EventBus 1]: /images/20220829/28b3642a7da24070805e4724c5045ff5.png