EventBus使用详解

矫情吗；* 2023-07-17 03:00 166阅读 0赞

前言

EventBus是一种用于Android的发布/订阅事件总线。它有很多优点：简化应用组件间的通信；解耦事件的发送者和接收者；避免复杂和容易出错的依赖和生命周期的问题；很快，专门为高性能优化过等等。

基础知识

EventBus使用了发布者/订阅者模式。

EventBus-Publish-Subscribe.png

发布者通过EventBus发布事件，订阅者通过EventBus订阅事件。当发布者发布事件时，订阅该事件的订阅者的事件处理方法将被调用。

使用详解

本文将按照如下顺序来介绍EventBus的使用：

  1. 准备工作
  2. 基本使用
  3. 线程模式
  4. 粘性事件
  5. 事件优先级
  6. 订阅者索引

文中所有的代码都放在了GitHub上：

https://github.com/chongyucaiyan/EventBusDemo

准备工作

首先，在模块的 build.gradle 构建脚本中添加EventBus依赖：

  1. dependencies {
  2.     ...
  3.     implementation 'org.greenrobot:eventbus:3.1.1'
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

接着，添加EventBus混淆规则。ProGuard工具混淆了方法名，并可能移除那些未被调用的方法。订阅者的事件处理方法没有被直接调用，如果开启了ProGuard工具的压缩功能，那么你必须告诉ProGuard工具保留这些订阅者方法。在模块的 proguard-rules.pro 混淆规则文件中添加如下规则：

  1. # EventBus
  2. -keepattributes *Annotation*
  3. -keepclassmembers class ** {
  4.     @org.greenrobot.eventbus.Subscribe <methods>;
  5. }
  6. -keep enum org.greenrobot.eventbus.ThreadMode { *; }
  12.    1
  13.    2
  14.    3
  15.    4
  16.    5
  17.    6

基本使用

EventBus的使用非常简单，主要分为3个步骤：

  1. 定义事件。
  2. 订阅事件。
  3. 发布事件。

第一步，定义事件。事件可以是任意普通的Java对象，没有任何特殊的要求。例如：

  1. public class MessageEvent { 
  2.     private String message;
  3.     public MessageEvent(String message) { 
  4.         this.message = message;
  5.     }
  6.     public String getMessage() { 
  7.         return message;
  8.     }
  9.     public void setMessage(String message) { 
  10.         this.message = message;
  11.     }
  12. }
  18.    1
  19.    2
  20.    3
  21.    4
  22.    5
  23.    6
  24.    7
  25.    8
  26.    9
  27.    10
  28.    11
  29.    12
  30.    13
  31.    14
  32.    15

第二步，订阅事件。订阅者需要定义事件处理方法（也称为订阅者方法）。当发布对应类型的事件时，该方法将被调用。EventBus 3使用 @Subscribe 注解来定义订阅者方法。方法名可以是任意合法的方法名，参数类型为订阅事件的类型。例如：

  1. @Subscribe(threadMode = ThreadMode.MAIN)
  2. public void onMessageEvent(MessageEvent event) { 
  3.     ...
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

订阅者还需要在总线上注册，并在不需要时在总线上注销。只有订阅者注册了，它们才会收到事件。在Android中，可以根据Activity或者Fragment的生命周期来注册和注销。例如：

  1. @Override
  2. protected void onCreate(Bundle savedInstanceState) { 
  3.     super.onCreate(savedInstanceState);
  4.     setContentView(R.layout.activity_main);
  5.     initContentView();
  6.     // 注册订阅者
  7.     EventBus.getDefault().register(this);
  8. }
  9. @Override
  10. protected void onDestroy() { 
  11.     super.onDestroy();
  12.     // 注销订阅者
  13.     EventBus.getDefault().unregister(this);
  14. }    
  20.    1
  21.    2
  22.    3
  23.    4
  24.    5
  25.    6
  26.    7
  27.    8
  28.    9
  29.    10
  30.    11
  31.    12
  32.    13
  33.    14
  34.    15

第三步，发布事件。在需要的地方发布事件，所有订阅了该类型事件并已注册的订阅者将收到该事件。例如：

  1. // 发布事件
  2. EventBus.getDefault().post(new MessageEvent("Hello EventBus!"));
  8.    1
  9.    2

下面是一个例子。订阅事件的代码如下所示：

  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     private static final String TAG = "MainActivity";
  3.     private TextView mTvMessage;
  4.     @Override
  5.     protected void onCreate(Bundle savedInstanceState) { 
  6.         super.onCreate(savedInstanceState);
  7.         setContentView(R.layout.activity_main);
  8.         initContentView();
  9.         // 注册订阅者
  10.         EventBus.getDefault().register(this);
  11.     }
  12.     private void initContentView() { 
  13.         Button btnStart = findViewById(R.id.btn_main_start_activity);
  14.         mTvMessage = findViewById(R.id.tv_main_message);
  15.         btnStart.setOnClickListener(this);
  16.     }
  17.     @Override
  18.     public void onClick(View v) { 
  19.         if (v.getId() == R.id.btn_main_start_activity) { 
  20.             SecondActivity.start(this);
  21.         }
  22.     }
  23.     @Subscribe(threadMode = ThreadMode.MAIN)
  24.     public void onMessageEvent(MessageEvent event) { 
  25.         Log.i(TAG, "message is " + event.getMessage());
  26.         // 更新界面
  27.         mTvMessage.setText(event.getMessage());
  28.     }
  29.     @Override
  30.     protected void onDestroy() { 
  31.         super.onDestroy();
  32.         // 注销订阅者
  33.         EventBus.getDefault().unregister(this);
  34.     }
  35. }
  41.    1
  42.    2
  43.    3
  44.    4
  45.    5
  46.    6
  47.    7
  48.    8
  49.    9
  50.    10
  51.    11
  52.    12
  53.    13
  54.    14
  55.    15
  56.    16
  57.    17
  58.    18
  59.    19
  60.    20
  61.    21
  62.    22
  63.    23
  64.    24
  65.    25
  66.    26
  67.    27
  68.    28
  69.    29
  70.    30
  71.    31
  72.    32
  73.    33
  74.    34
  75.    35
  76.    36
  77.    37
  78.    38
  79.    39
  80.    40
  81.    41

MainActivity订阅了MessageEvent事件。当接收到MessageEvent事件时，订阅者方法将打印日志消息，并更新界面上的TextView。

发布事件的代码如下所示：

  1. public class SecondActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     public static void start(Context context) { 
  3.         Intent intent = new Intent(context, SecondActivity.class);
  4.         context.startActivity(intent);
  5.     }
  6.     @Override
  7.     protected void onCreate(Bundle savedInstanceState) { 
  8.         super.onCreate(savedInstanceState);
  9.         setContentView(R.layout.activity_second);
  10.         initContentView();
  11.     }
  12.     private void initContentView() { 
  13.         findViewById(R.id.btn_second_post_event).setOnClickListener(this);
  14.     }
  15.     @Override
  16.     public void onClick(View v) { 
  17.         if (v.getId() == R.id.btn_second_post_event) { 
  18.             // 发布事件
  19.             EventBus.getDefault().post(new MessageEvent("Hello EventBus!"));
  20.         }
  21.     }
  22. }
  28.    1
  29.    2
  30.    3
  31.    4
  32.    5
  33.    6
  34.    7
  35.    8
  36.    9
  37.    10
  38.    11
  39.    12
  40.    13
  41.    14
  42.    15
  43.    16
  44.    17
  45.    18
  46.    19
  47.    20
  48.    21
  49.    22
  50.    23
  51.    24
  52.    25
  53.    26

当点击发布事件的按钮时，SecondActivity将发布一个MessageEvent事件。

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

  1. 12-27 20:59:18.919 24705-24705/com.github.cyc.eventbus.basicusedemo I/MainActivity: message is Hello EventBus!
  7.    1

线程模式

EventBus支持订阅者方法在不同于发布事件所在线程的线程中被调用。你可以使用线程模式来指定调用订阅者方法的线程。EventBus总共支持5种线程模式：

  • ThreadMode.POSTING 订阅者方法将在发布事件所在的线程中被调用。这是 默认的线程模式。事件的传递是同步的，一旦发布事件，所有该模式的订阅者方法都将被调用。这种线程模式意味着最少的性能开销，因为它避免了线程的切换。因此，对于不要求是主线程并且耗时很短的简单任务推荐使用该模式。使用该模式的订阅者方法应该快速返回，以避免阻塞发布事件的线程，这可能是主线程。
  • ThreadMode.MAIN 订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。如果发布事件的线程是主线程，那么该模式的订阅者方法将被直接调用。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。
  • ThreadMode.MAIN_ORDERED 订阅者方法将在主线程（UI线程）中被调用。因此，可以在该模式的订阅者方法中直接更新UI界面。事件将先进入队列然后才发送给订阅者，所以发布事件的调用将立即返回。这使得事件的处理保持严格的串行顺序。使用该模式的订阅者方法必须快速返回，以避免阻塞主线程。
  • ThreadMode.BACKGROUND 订阅者方法将在后台线程中被调用。如果发布事件的线程不是主线程，那么订阅者方法将直接在该线程中被调用。如果发布事件的线程是主线程，那么将使用一个单独的后台线程，该线程将按顺序发送所有的事件。使用该模式的订阅者方法应该快速返回，以避免阻塞后台线程。
  • ThreadMode.ASYNC 订阅者方法将在一个单独的线程中被调用。因此，发布事件的调用将立即返回。如果订阅者方法的执行需要一些时间，例如网络访问，那么就应该使用该模式。避免触发大量的长时间运行的订阅者方法，以限制并发线程的数量。EventBus使用了一个线程池来有效地重用已经完成调用订阅者方法的线程。

下面是一个例子。订阅事件的代码如下所示：

  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     private static final String TAG = "MainActivity";
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState);
  6.         setContentView(R.layout.activity_main);
  7.         initContentView();
  8.         // 注册订阅者
  9.         EventBus.getDefault().register(this);
  10.     }
  11.     private void initContentView() { 
  12.         findViewById(R.id.btn_main_start_activity).setOnClickListener(this);
  13.     }
  14.     @Override
  15.     public void onClick(View v) { 
  16.         if (v.getId() == R.id.btn_main_start_activity) { 
  17.             SecondActivity.start(this);
  18.         }
  19.     }
  20.     @Subscribe(threadMode = ThreadMode.POSTING)
  21.     public void onMessageEventPosting(MessageEvent event) { 
  22.         Log.i(TAG, "onMessageEventPosting(), current thread is " + Thread.currentThread().getName());
  23.     }
  24.     @Subscribe(threadMode = ThreadMode.MAIN)
  25.     public void onMessageEventMain(MessageEvent event) { 
  26.         Log.i(TAG, "onMessageEventMain(), current thread is " + Thread.currentThread().getName());
  27.     }
  28.     @Subscribe(threadMode = ThreadMode.MAIN_ORDERED)
  29.     public void onMessageEventMainOrdered(MessageEvent event) { 
  30.         Log.i(TAG, "onMessageEventMainOrdered(), current thread is " + Thread.currentThread().getName());
  31.     }
  32.     @Subscribe(threadMode = ThreadMode.BACKGROUND)
  33.     public void onMessageEventBackground(MessageEvent event) { 
  34.         Log.i(TAG, "onMessageEventBackground(), current thread is " + Thread.currentThread().getName());
  35.     }
  36.     @Subscribe(threadMode = ThreadMode.ASYNC)
  37.     public void onMessageEventAsync(MessageEvent event) { 
  38.         Log.i(TAG, "onMessageEventAsync(), current thread is " + Thread.currentThread().getName());
  39.     }
  40.     @Override
  41.     protected void onDestroy() { 
  42.         super.onDestroy();
  43.         // 注销订阅者
  44.         EventBus.getDefault().unregister(this);
  45.     }
  46. }
  52.    1
  53.    2
  54.    3
  55.    4
  56.    5
  57.    6
  58.    7
  59.    8
  60.    9
  61.    10
  62.    11
  63.    12
  64.    13
  65.    14
  66.    15
  67.    16
  68.    17
  69.    18
  70.    19
  71.    20
  72.    21
  73.    22
  74.    23
  75.    24
  76.    25
  77.    26
  78.    27
  79.    28
  80.    29
  81.    30
  82.    31
  83.    32
  84.    33
  85.    34
  86.    35
  87.    36
  88.    37
  89.    38
  90.    39
  91.    40
  92.    41
  93.    42
  94.    43
  95.    44
  96.    45
  97.    46
  98.    47
  99.    48
  100.    49
  101.    50
  102.    51
  103.    52
  104.    53
  105.    54
  106.    55

MainActivity订阅了MessageEvent事件，定义了5个不同线程模式的订阅者方法。当接收到MessageEvent事件时，订阅者方法将打印当前所在的线程名。

发布事件的代码如下所示：

  1. public class SecondActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     public static void start(Context context) { 
  3.         Intent intent = new Intent(context, SecondActivity.class);
  4.         context.startActivity(intent);
  5.     }
  6.     @Override
  7.     protected void onCreate(Bundle savedInstanceState) { 
  8.         super.onCreate(savedInstanceState);
  9.         setContentView(R.layout.activity_second);
  10.         initContentView();
  11.     }
  12.     private void initContentView() { 
  13.         findViewById(R.id.btn_second_post_event).setOnClickListener(this);
  14.     }
  15.     @Override
  16.     public void onClick(View v) { 
  17.         if (v.getId() == R.id.btn_second_post_event) { 
  18.             // 发布事件
  19.             new Thread("posting") { 
  20.                 @Override
  21.                 public void run() { 
  22.                     EventBus.getDefault().post(new MessageEvent("Hello EventBus!"));
  23.                 }
  24.             }.start();
  25.         }
  26.     }
  27. }
  33.    1
  34.    2
  35.    3
  36.    4
  37.    5
  38.    6
  39.    7
  40.    8
  41.    9
  42.    10
  43.    11
  44.    12
  45.    13
  46.    14
  47.    15
  48.    16
  49.    17
  50.    18
  51.    19
  52.    20
  53.    21
  54.    22
  55.    23
  56.    24
  57.    25
  58.    26
  59.    27
  60.    28
  61.    29
  62.    30
  63.    31
  64.    32

当点击发布事件的按钮时，SecondActivity将在一个名为”posting”的线程中发布一个MessageEvent事件。

运行应用。点击MainActivity界面上的启动活动按钮来启动SecondActivity，然后点击SecondActivity界面上的发布事件按钮来发布事件。应用打印出如下信息：

  1. 12-27 22:12:05.745 6003-6117/com.github.cyc.eventbus.threadmodedemo I/MainActivity: onMessageEventBackground(), current thread is posting
  2. 12-27 22:12:05.746 6003-6117/com.github.cyc.eventbus.threadmodedemo I/MainActivity: onMessageEventPosting(), current thread is posting
  3. 12-27 22:12:05.752 6003-6003/com.github.cyc.eventbus.threadmodedemo I/MainActivity: onMessageEventMain(), current thread is main
  4. 12-27 22:12:05.752 6003-6003/com.github.cyc.eventbus.threadmodedemo I/MainActivity: onMessageEventMainOrdered(), current thread is main
  5. 12-27 22:12:05.754 6003-6118/com.github.cyc.eventbus.threadmodedemo I/MainActivity: onMessageEventAsync(), current thread is pool-1-thread-1
  11.    1
  12.    2
  13.    3
  14.    4
  15.    5

粘性事件

如果先发布了事件，然后有订阅者订阅了该事件，那么除非再次发布该事件，否则订阅者将永远接收不到该事件。此时，可以使用粘性事件。发布一个粘性事件之后，EventBus将在内存中缓存该粘性事件。当有订阅者订阅了该粘性事件，订阅者将接收到该事件。

订阅和发布一个粘性事件的示例代码如下所示：

  1. // 订阅粘性事件
  2. @Subscribe(sticky = true)
  3. public void onMessageEvent(MessageEvent event) { 
  4.     ...
  5. }
  6. // 发布粘性事件
  7. EventBus.getDefault().postSticky(new MessageEvent("Hello EventBus!"));
  13.    1
  14.    2
  15.    3
  16.    4
  17.    5
  18.    6
  19.    7
  20.    8

发布一个粘性事件之后，EventBus将一直缓存该粘性事件。如果想要移除粘性事件，那么可以使用如下方法：

  1. // 移除指定的粘性事件
  2. removeStickyEvent(Object event);
  3. // 移除指定类型的粘性事件
  4. removeStickyEvent(Class<T> eventType);
  5. // 移除所有的粘性事件
  6. removeAllStickyEvents();
  12.    1
  13.    2
  14.    3
  15.    4
  16.    5
  17.    6
  18.    7
  19.    8

下面是一个例子。发布粘性事件的代码如下所示：

  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     @Override
  3.     protected void onCreate(Bundle savedInstanceState) { 
  4.         super.onCreate(savedInstanceState);
  5.         setContentView(R.layout.activity_main);
  6.         initContentView();
  7.     }
  8.     private void initContentView() { 
  9.         findViewById(R.id.btn_main_post_event).setOnClickListener(this);
  10.         findViewById(R.id.btn_main_start_activity).setOnClickListener(this);
  11.     }
  12.     @Override
  13.     public void onClick(View v) { 
  14.         switch (v.getId()) { 
  15.             case R.id.btn_main_post_event:
  16.                 // 发布粘性事件
  17.                 EventBus.getDefault().postSticky(new MessageEvent("Hello EventBus!"));
  18.                 break;
  19.             case R.id.btn_main_start_activity:
  20.                 SecondActivity.start(this);
  21.                 break;
  22.             default:
  23.                 break;
  24.         }
  25.     }
  26. }
  32.    1
  33.    2
  34.    3
  35.    4
  36.    5
  37.    6
  38.    7
  39.    8
  40.    9
  41.    10
  42.    11
  43.    12
  44.    13
  45.    14
  46.    15
  47.    16
  48.    17
  49.    18
  50.    19
  51.    20
  52.    21
  53.    22
  54.    23
  55.    24
  56.    25
  57.    26
  58.    27
  59.    28
  60.    29
  61.    30
  62.    31

当点击发布粘性事件的按钮时，MainActivity将发布一个MessageEvent粘性事件。

订阅粘性事件的代码如下所示：

  1. public class SecondActivity extends AppCompatActivity { 
  2.     private static final String TAG = "SecondActivity";
  3.     private TextView mTvMessage;
  4.     public static void start(Context context) { 
  5.         Intent intent = new Intent(context, SecondActivity.class);
  6.         context.startActivity(intent);
  7.     }
  8.     @Override
  9.     protected void onCreate(Bundle savedInstanceState) { 
  10.         super.onCreate(savedInstanceState);
  11.         setContentView(R.layout.activity_second);
  12.         initContentView();
  13.         // 注册订阅者
  14.         EventBus.getDefault().register(this);
  15.     }
  16.     private void initContentView() { 
  17.         mTvMessage = findViewById(R.id.tv_second_message);
  18.     }
  19.     @Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
  20.     public void onMessageEvent(MessageEvent event) { 
  21.         Log.i(TAG, "message is " + event.getMessage());
  22.         // 更新界面
  23.         mTvMessage.setText(event.getMessage());
  24.         // 移除粘性事件
  25.         EventBus.getDefault().removeStickyEvent(event);
  26.     }
  27.     @Override
  28.     protected void onDestroy() { 
  29.         super.onDestroy();
  30.         // 注销订阅者
  31.         EventBus.getDefault().unregister(this);
  32.     }
  33. }
  39.    1
  40.    2
  41.    3
  42.    4
  43.    5
  44.    6
  45.    7
  46.    8
  47.    9
  48.    10
  49.    11
  50.    12
  51.    13
  52.    14
  53.    15
  54.    16
  55.    17
  56.    18
  57.    19
  58.    20
  59.    21
  60.    22
  61.    23
  62.    24
  63.    25
  64.    26
  65.    27
  66.    28
  67.    29
  68.    30
  69.    31
  70.    32
  71.    33
  72.    34
  73.    35
  74.    36
  75.    37
  76.    38
  77.    39

SecondActivity订阅了MessageEvent粘性事件。当接收到MessageEvent粘性事件时，订阅者方法将打印日志消息，并更新界面上的TextView，最后移除该粘性事件。

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

  1. 12-27 22:52:16.975 7684-7684/com.github.cyc.eventbus.stickyeventdemo I/SecondActivity: message is Hello EventBus!
  7.    1

事件优先级

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

指定事件传递优先级的示例代码如下所示：

  1. @Subscribe(priority = 1)
  2. public void onMessageEvent(MessageEvent event) { 
  3.     ...
  4. }
  10.    1
  11.    2
  12.    3
  13.    4

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

取消事件传递的示例代码如下所示：

  1. @Subscribe(threadMode = ThreadMode.POSTING, priority = 1)
  2. public void onMessageEvent(MessageEvent event) { 
  3.     ...
  4.     // 取消事件传递
  5.     EventBus.getDefault().cancelEventDelivery(event);
  6. }
  12.    1
  13.    2
  14.    3
  15.    4
  16.    5
  17.    6

下面是一个例子。订阅事件的代码如下所示：

  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     private static final String TAG = "MainActivity";
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) { 
  5.         super.onCreate(savedInstanceState);
  6.         setContentView(R.layout.activity_main);
  7.         initContentView();
  8.         // 注册订阅者
  9.         EventBus.getDefault().register(this);
  10.     }
  11.     private void initContentView() { 
  12.         findViewById(R.id.btn_main_start_activity).setOnClickListener(this);
  13.     }
  14.     @Override
  15.     public void onClick(View v) { 
  16.         if (v.getId() == R.id.btn_main_start_activity) { 
  17.             SecondActivity.start(this);
  18.         }
  19.     }
  20.     @Subscribe(threadMode = ThreadMode.POSTING, priority = 1)
  21.     public void onMessageEvent1(MessageEvent event) { 
  22.         Log.i(TAG, "onMessageEvent1(), message is " + event.getMessage());
  23.     }
  24.     @Subscribe(threadMode = ThreadMode.POSTING, priority = 2)
  25.     public void onMessageEvent2(MessageEvent event) { 
  26.         Log.i(TAG, "onMessageEvent2(), message is " + event.getMessage());
  27.         // 取消事件
  28.         EventBus.getDefault().cancelEventDelivery(event);
  29.     }
  30.     @Subscribe(threadMode = ThreadMode.POSTING, priority = 3)
  31.     public void onMessageEvent3(MessageEvent event) { 
  32.         Log.i(TAG, "onMessageEvent3(), message is " + event.getMessage());
  33.     }
  34.     @Subscribe(threadMode = ThreadMode.POSTING, priority = 4)
  35.     public void onMessageEvent4(MessageEvent event) { 
  36.         Log.i(TAG, "onMessageEvent4(), message is " + event.getMessage());
  37.     }
  38.     @Subscribe(threadMode = ThreadMode.POSTING, priority = 5)
  39.     public void onMessageEvent5(MessageEvent event) { 
  40.         Log.i(TAG, "onMessageEvent5(), message is " + event.getMessage());
  41.     }
  42.     @Override
  43.     protected void onDestroy() { 
  44.         super.onDestroy();
  45.         // 注销订阅者
  46.         EventBus.getDefault().unregister(this);
  47.     }
  48. }
  54.    1
  55.    2
  56.    3
  57.    4
  58.    5
  59.    6
  60.    7
  61.    8
  62.    9
  63.    10
  64.    11
  65.    12
  66.    13
  67.    14
  68.    15
  69.    16
  70.    17
  71.    18
  72.    19
  73.    20
  74.    21
  75.    22
  76.    23
  77.    24
  78.    25
  79.    26
  80.    27
  81.    28
  82.    29
  83.    30
  84.    31
  85.    32
  86.    33
  87.    34
  88.    35
  89.    36
  90.    37
  91.    38
  92.    39
  93.    40
  94.    41
  95.    42
  96.    43
  97.    44
  98.    45
  99.    46
  100.    47
  101.    48
  102.    49
  103.    50
  104.    51
  105.    52
  106.    53
  107.    54
  108.    55
  109.    56
  110.    57

MainActivity订阅了MessageEvent事件，定义了5个不同优先级的订阅者方法。当接收到MessageEvent事件时，订阅者方法将打印日志消息。优先级为2的订阅者方法在接收到事件之后取消了事件的传递。

发布事件的代码如下所示：

  1. public class SecondActivity extends AppCompatActivity implements View.OnClickListener { 
  2.     public static void start(Context context) { 
  3.         Intent intent = new Intent(context, SecondActivity.class);
  4.         context.startActivity(intent);
  5.     }
  6.     @Override    protected void onCreate(Bundle savedInstanceState) { 
  7.         super.onCreate(savedInstanceState);        setContentView(R.layout.activity_second);
  8.         initContentView();
  9.     }
  10.     private void initContentView() { 
  11.         findViewById(R.id.btn_second_post_event).setOnClickListener(this);
  12.     }
  13.     @Override
  14.     public void onClick(View v) { 
  15.         if (v.getId() == R.id.btn_second_post_event) { 
  16.             // 发布事件
  17.             EventBus.getDefault().post(new MessageEvent("Hello EventBus!"));
  18.         }
  19.     }
  20. }
  26.    1
  27.    2
  28.    3
  29.    4
  30.    5
  31.    6
  32.    7
  33.    8
  34.    9
  35.    10
  36.    11
  37.    12
  38.    13
  39.    14
  40.    15
  41.    16
  42.    17
  43.    18
  44.    19
  45.    20
  46.    21
  47.    22
  48.    23
  49.    24
  50.    25
  51.    26

当点击发布事件的按钮时，SecondActivity将发布一个MessageEvent事件。

运行应用。点击MainActivity界面上的启动活动按钮来启动SecondActivity，然后点击SecondActivity界面上的发布事件按钮来发布事件。应用打印出如下信息：

  1. 12-28 01:03:27.751 22428-22428/com.github.cyc.eventbus.eventprioritydemo I/MainActivity: onMessageEvent5(), message is Hello EventBus!
  2. 12-28 01:03:27.751 22428-22428/com.github.cyc.eventbus.eventprioritydemo I/MainActivity: onMessageEvent4(), message is Hello EventBus!
  3. 12-28 01:03:27.751 22428-22428/com.github.cyc.eventbus.eventprioritydemo I/MainActivity: onMessageEvent3(), message is Hello EventBus!
  4. 12-28 01:03:27.752 22428-22428/com.github.cyc.eventbus.eventprioritydemo I/MainActivity: onMessageEvent2(), message is Hello EventBus!
  10.    1
  11.    2
  12.    3
  13.    4

订阅者索引

默认情况下，EventBus在查找订阅者方法时采用的是反射。订阅者索引是EventBus 3的一个新特性。它可以加速订阅者的注册，是一个可选的优化。订阅者索引的原理是：使用EventBus的注解处理器在应用构建期间创建订阅者索引类，该类包含了订阅者和订阅者方法的相关信息。EventBus官方推荐在Android中使用订阅者索引以获得最佳的性能。

要开启订阅者索引的生成，你需要在构建脚本中使用annotationProcessor属性将EventBus的注解处理器添加到应用的构建中，还要设置一个eventBusIndex参数来指定要生成的订阅者索引的完全限定类名。

我们在前面的基本使用的那个例子上进行修改。首先，修改模块下的build.gradle构建脚本：

  1. android {
  2.     defaultConfig {
  3.         ...
  4.         javaCompileOptions {
  5.             annotationProcessorOptions {
  6.                 arguments = [eventBusIndex: 'com.github.cyc.eventbus.subscriberindexdemo.MyEventBusIndex']
  7.             }
  8.         }
  9.     }
  10.     ...
  11. }
  12. dependencies {
  13.     ...
  14.     compile 'org.greenrobot:eventbus:3.1.1'
  15.     annotationProcessor 'org.greenrobot:eventbus-annotation-processor:3.1.1'
  16. }
  22.    1
  23.    2
  24.    3
  25.    4
  26.    5
  27.    6
  28.    7
  29.    8
  30.    9
  31.    10
  32.    11
  33.    12
  34.    13
  35.    14
  36.    15
  37.    16
  38.    17

然后，build一下工程。EventBus注解处理器将为你生成一个订阅者索引类。如下所示：

  1. package com.github.cyc.eventbus.subscriberindexdemo;
  2. import org.greenrobot.eventbus.meta.SimpleSubscriberInfo;
  3. import org.greenrobot.eventbus.meta.SubscriberMethodInfo;
  4. import org.greenrobot.eventbus.meta.SubscriberInfo;
  5. import org.greenrobot.eventbus.meta.SubscriberInfoIndex;
  6. import org.greenrobot.eventbus.ThreadMode;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. /** This class is generated by EventBus, do not edit. */
  10. public class MyEventBusIndex implements SubscriberInfoIndex { 
  11.     private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;
  12.     static { 
  13.         SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();
  14.         putIndex(new SimpleSubscriberInfo(MainActivity.class, true, new SubscriberMethodInfo[] { 
  15.             new SubscriberMethodInfo("onMessageEvent", MessageEvent.class, ThreadMode.MAIN),
  16.         }));
  17.     }
  18.     private static void putIndex(SubscriberInfo info) { 
  19.         SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
  20.     }
  21.     @Override
  22.     public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) { 
  23.         SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
  24.         if (info != null) { 
  25.             return info;
  26.         } else { 
  27.             return null;
  28.         }
  29.     }
  30. }
  36.    1
  37.    2
  38.    3
  39.    4
  40.    5
  41.    6
  42.    7
  43.    8
  44.    9
  45.    10
  46.    11
  47.    12
  48.    13
  49.    14
  50.    15
  51.    16
  52.    17
  53.    18
  54.    19
  55.    20
  56.    21
  57.    22
  58.    23
  59.    24
  60.    25
  61.    26
  62.    27
  63.    28
  64.    29
  65.    30
  66.    31
  67.    32
  68.    33
  69.    34
  70.    35
  71.    36
  72.    37
  73.    38
  74.    39

最后，在应用自定义的Application类的onCreate()方法中将订阅者索引类添加到EventBus中，并将该EventBus设置成默认的EventBus。示例代码如下所示：

  1. public class MyApplication extends Application { 
  2.     @Override
  3.     public void onCreate() { 
  4.         super.onCreate();
  5.         // 配置EventBus
  6.         EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();
  7.     }
  8. }
  14.    1
  15.    2
  16.    3
  17.    4
  18.    5
  19.    6
  20.    7
  21.    8
  22.    9

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

  1. 12-28 02:06:57.365 11335-11335/com.github.cyc.eventbus.subscriberindexdemo I/MainActivity: message is Hello EventBus!
  7.    1

源码分析

EventBus的源码分析可以阅读下面这篇文章：

EventBus源码分析

总结

EventBus是一种用于Android的发布/订阅事件总线。使用EventBus可以简化应用组件间的通信，可以解耦事件的发送者和接收者。

参考

  • EventBus 3.1.1
  • http://greenrobot.org/eventbus/
  • https://github.com/greenrobot/EventBus

发表评论

表情：
评论列表 （有 0 条评论，166人围观）

还没有评论，来说两句吧...

相关阅读

    相关 EventBus使用详解

    前言 EventBus是一种用于Android的发布/订阅事件总线。它有很多优点：简化应用组件间的通信；解耦事件的发送者和接收者；避免复杂和容易出错的依赖和生命周期的问题

    矫情吗；*矫情吗；*/ 0 赞/ 167 阅读

    相关 EventBus使用详解

    前言 EventBus是一种用于Android的发布/订阅事件总线。它有很多优点：简化应用组件间的通信；解耦事件的发送者和接收者；避免复杂和容易出错的依赖和生命周期的问题

    ╰半橙微兮°╰半橙微兮°/ 0 赞/ 212 阅读

    相关 EventBus的基本使用

    【 EventBus是一款本地组件间通信框架。在大型项目的Activities，fragments，Threads，Services都可以看到它的使用场景，尽管EventBu

    蔚落蔚落/ 0 赞/ 293 阅读

    相关 EventBus使用详解

    > > 前言：EventBus出来已经有一段时间了，github上面也有很多开源项目中使用了EventBus。所以抽空学习顺便整理了一下。目前EventBus最新版本是3

    怼烎@怼烎@/ 0 赞/ 293 阅读

    相关 Guava EventBus 使用

    Guava EventBus 使用 EventBus 是 Google Guava 提供的消息发布-订阅类库，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现，

    水深无声水深无声/ 0 赞/ 463 阅读