×

EventBus源码解析(一)关于用法和注解

96
Hohohong
2017.03.12 16:49* 字数 2907

文章基于EventBus 3.0讲解。
首先对于EventBus的使用上,大多数人还是比较熟悉的。如果你还每次烦于使用接口回调,广播去更新数据,那么EventBus可以帮助你解决这个问题。
第一篇主要将一些用法和注解

EventBus源码解析系列

EventBus源码解析(一)关于用法和注解
EventBus源码解析(二)register与unregister
EventBus源码解析(三)Post方法和注解处理器

一. 使用

先从平常我们的使用方法看,Service处理数据,处理完发给Activity做显示

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView)findViewById(R.id.tv);
        EventBus.getDefault().register(this);
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                Intent intent = new Intent(MainActivity.this , TestService.class);
                startService(intent);
            }
        } , 3000);
        Log.e(TAG, "onCreate: " );
    }

    @Subscribe
    public void onEventMainThread(String s){
        Log.e(TAG, "onEventMainThread: " + s );
        tv.setText(s);
    }

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

在onCreate调用了EventBus.getDefault().register(this);,在onDestory解除了注册。注册之后就可以在@Subcribe注解下面的方法接收到。而发送事件则是在Service

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        EventBus.getDefault().post("Service Test");
        return super.onStartCommand(intent, flags, startId);
    }

Service和Activity之间的通讯通过EventBus就可以很简单的实现出了,如果换成以前的话,则是使用

  • 接口回调
  • IBinder
  • 广播

来进行联系,但是如果这样的话一些代码上就会显得有些冗余,而使用EventBus则可以很简便。

此外,这EventBus的版本迭代上,在3.0则是采用了注解来进行监听事件。
上面那个监听方法

@Subscribe
    public void onEventMainThread(String s){
        Log.e(TAG, "onEventMainThread: " + s );
        tv.setText(s);
    }

只要通过@Subcribe注解的方法,且类型是public的,方法名可以自由取

@Subscribe
    public void test(String s){
        Log.e(TAG, "onEventMainThread: " + s );
        tv.setText(s);
    }

而在3.0之前则默认了onEvent+类型 的方法名,然后通过反射来获取对应的方法。

    //3.0前的版本
    public void onEventMainThread(String s){
        Log.e(TAG, "onEventMainThread: " + s );
        tv.setText(s);
    }

二.注解

这里主要说说注解的使用与实例。没知道注解的可以了解的。
前面讲到了EventBus的一个注解@Subscribe,点进去看下类型

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;
    ...
    boolean sticky() default false;
    ...
    int priority() default 0;
}

没了解过注解的话可能会有点懵。

注解的语法其实比较简单,除了@符号的使用外,它基本与Java固有的语法一样。Java SE5则内置了三种标准的注解

  • @Override:表示当前的方法将覆盖超类中的方法
  • @Deprecated:使用了注解为它的元素编译器将发出警告,因为@Deprecated注解是被弃用的代码,不被赞成
  • @SuppressWarnings:关闭编译器警告信息

对于上述的三个注解大家在日常开发中算是经常见到的,点进去看他们的结构也和@Subscribe差不多.

Java提供了4种注解
  • @Target :表示该注解可以用于什么地方,可能的ElementType参数有:

  • @Retention:表明需要在什么级别保存该注解信息。可选的RetentionPolicy参数包括:

    • SOURCE:注解将被编译器丢弃
    • CLASS:注解在class文件中可用,但会被VM丢弃
    • RUNTIME:VM将在运行期间保留注解,因此可以通过反射机制读取注解的信息。
  • @Document:将注解包含在Javadoc中

  • @Inherited:允许子类继承父类中的注解

定义一个注解的方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}

除了@符号,注解很像是一个接口。定义注解的时候需要用到元注解,上面用到了@Target@RetentionPolicy,它们的含义在上面已给出。

在注解中一般会有一些元素来表示某些值,注解里面的元素看起来很像接口的方法,唯一区别在于注解可以为其制定默认值,没有元素的注解称为标记注解,上面的Test就是一个标记注解。

注解的可用的类型包括以下几种:所有基本类型、String、Class、enum、Annotation、以上类型的数组形式。元素不能有不确定的值,即要么有默认值,要么在使用注解的时候提供元素的值。而且元素不能使用null作为默认值。注解在只有一个元素且该元素的名称是value的情况下,在使用注解的时候可以省略“value=”,直接写需要的值即可。

比如

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    public String id();
    public String userName() default "Hohohong";
}

这里则有两个元素,他们的类型是String型,第二个元素则设置了默认值。再看下前面@Subscrive注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;
    ...
    boolean sticky() default false;
    ...
    int priority() default 0;
}

它保留在VM运行时,用于方法上。三个元素中,第一个元素的类型是Enum型,默认值则为ThreadMode.POSTING,也比较好理解了。

定义好注解之后,就是如何使用了

public class TestUtil {
    @Test(id="0" , userName = "Hong")
    public void getData(String data){
        Log.e("TestUtil", "getData: " + data );
    }

    @Test(id="1")
    public void dataTest(){
        Log.e("TestUtil", "dataTest" );
    }

使用注解最主要的部分在于对注解的处理,那么就会涉及到注解处理器。

从原理上讲,注解处理器就是通过反射机制获取被检查方法上的注解信息,然后根据注解元素的值进行特定的处理。

 public static void main(String args[]){
        trackTest(TestUtil.class);
    }
    public static void trackTest(Class<?> cls){
        Method[] methods = cls.getMethods();
        for(Method method : methods){
            Test test = method.getAnnotation(Test.class);
            if(test != null){
                System.out.println("Found Test : id = " + test.id() + "  userName = " + test.userName() );
            }
        }
    }

这里就可以拿到每个注解方法上注解的一些属性。
关于注解更多的使用就不扩展开了。

三.EventBus的注解

还是前面那个@Subscribe

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;
    ...
    boolean sticky() default false;
    ...
    int priority() default 0;
}

ThreadMode是一个enum类型,里面定义了四种类型

public enum ThreadMode {
   
    POSTING,

    MAIN,

    BACKGROUND,

    ASYNC
}

对应的方法则为

  • onEventPostThread:代表这个方法会在当前发布事件的线程执行,也就是执行事件和发送事件都在同一个线程中。(默认是这个)

  • onEventMainThread:代表这个方法会在主线程执行

  • onEventBackgroundThread:如果发送事件的线程不是UI线程,则运行在该线程中。如果发送事件的是UI线程,则它运行在由EventBus维护的一个单独的线程池中,事件会加入后台任务队列,使用线程池一个接一个调用。

  • onEventAsync:运行在单独的工作线程中,不论发送事件的线程是否为主线程。跟BackgroundThread不一样,该模式的所有线程是独立的,因此适用于长耗时操作,例如网络访问。它也是使用线程池调用,注意没有BackgroundThread中的一个接一个。

3.1ThreadMode.POSTING

首先@Subscribe它里面ThreadMode默认值是POSTING,也就是说,执行事件和发送事件在同一个线程。

@Subscribe
    public void onEventMainThread(String s){
        Log.e(TAG, "Current Thread name: " + Thread.currentThread().getName() );
        Log.e(TAG, "Current Thread is MainThread? : " + (Thread.currentThread() == Looper.getMainLooper().getThread()) );
        tv.setText(s); //主线程才能更新UI,如果POST在子线程运行则报错
    }
@Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        EventBus.getDefault().post("Service Test");
        return super.onStartCommand(intent, flags, startId);
    }

当然这里的方法名是随便的,如果发送事件在子线程的话可能会有点误区。结果为

 E/MainActivity: Current Thread name: main
 E/MainActivity: Current Thread is MainThread? : true

如果在子线程Post

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                EventBus.getDefault().post("Service Test");
            }
        } , "childThread").start();
        return super.onStartCommand(intent, flags, startId);
    }

结果则为

E/MainActivity: Current Thread name: childThread
E/MainActivity: Current Thread is MainThread? : false

此时在方法里则不能进行UI更新操作。此时如果把它的模式设置为MAIN,则没问题

3.2 ThreadMode.MAIN

@Subscribe(threadMode = ThreadMode.MAIN)
    public void onEventMainThread(String s){
        Log.e(TAG, "Current Thread name: " + Thread.currentThread().getName() );
        Log.e(TAG, "Current Thread is MainThread? : " + (Thread.currentThread() == Looper.getMainLooper().getThread()) );
        tv.setText(s);
    }

结果则跟前面一样,MAIN则是无论发送事件是否在主线程,执行事件总是在主线程

 E/MainActivity: Current Thread name: main
 E/MainActivity: Current Thread is MainThread? : true

3.3 ThreadMode.BACKGROUND

来验证下BACKGROUND,前面介绍则是如果发送事件的线程不是UI线程,则运行在该线程中。如果发送事件的是UI线程,则它运行在由EventBus维护的一个单独的线程池中。延续前面的例子,发送事件是在子线程childThread中,执行事件方法我们指定为ThreadMode.BACKGROUND

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                EventBus.getDefault().post("Service Test");
            }
        } , "childThread").start();
        return super.onStartCommand(intent, flags, startId);
    }
 @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onEventMainThread(String s){
        Log.e(TAG, "Current Thread name: " + Thread.currentThread().getName() );
        Log.e(TAG, "Current Thread is MainThread? : " + (Thread.currentThread() == Looper.getMainLooper().getThread()) );
        tv.setText(s);
    }

此时结果则为

E/MainActivity: Current Thread name: childThread
E/MainActivity: Current Thread is MainThread? : false

跟描述的一样
我们将发送事件的方法放到UI线程看下

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
                EventBus.getDefault().post("Service Test");
        return super.onStartCommand(intent, flags, startId);
    }

结果则为

E/MainActivity: Current Thread name: pool-1-thread-1
E/MainActivity: Current Thread is MainThread? : false

可以看到它运行在EventBus维护的一个线程池中。

3.3 ThreadMode.ASYNC

和前面一样做测试,就不贴出代码,直接给出测试结果。
无论当前发送事件是否在主线程还是子线程,执行事件都是在EventBus的线程池中

E/MainActivity: Current Thread name: pool-1-thread-1
E/MainActivity: Current Thread is MainThread? : false

那么从这一点上看又与ThreadMode.BACKGROUND有什么不用呢,前面说到,BACKGROUND里面的线程池会把当前事件添加到任务队列,一个执行完才到下一个,而ThreadMode.ASYNC从名字上看就知道是异步的,也就是每个事件都可以同时并发执行。

我们看下测试用例
首先,我们一连发送3个事件

 @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        EventBus.getDefault().post("1 Service Test");
        EventBus.getDefault().post("2 Service Test");
        EventBus.getDefault().post("3 Service Test");
        return super.onStartCommand(intent, flags, startId);
    }

模式指定为BACKGROUND

 @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onEventMainThread(String s){
        Log.e(TAG, "currrent String : " + s );
        Log.e(TAG, "Current Thread name: " + Thread.currentThread().getName() );
        Log.e(TAG, "Current Thread is MainThread? : " + (Thread.currentThread() == Looper.getMainLooper().getThread()) );
        //tv.setText(s);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

看下结果输出

03-12 04:29:43.259 E/MainActivity: currrent String : 1 Service Test
03-12 04:29:43.259 E/MainActivity: Current Thread name: pool-1-thread-1
03-12 04:29:43.259 E/MainActivity: Current Thread is MainThread? : false

03-12 04:29:46.263 E/MainActivity: currrent String : 2 Service Test
03-12 04:29:46.263 E/MainActivity: Current Thread name: pool-1-thread-1
03-12 04:29:46.263 E/MainActivity: Current Thread is MainThread? : false

03-12 04:29:49.263 E/MainActivity: currrent String : 3 Service Test
03-12 04:29:49.263 E/MainActivity: Current Thread name: pool-1-thread-1
03-12 04:29:49.263 E/MainActivity: Current Thread is MainThread? : false

可以看到他们里面用的都是同一个线程,一个事件在执行,另一个事件则需要等待。

再看下指定为ThreadMode.ASYNC的结果

03-12 04:27:43.435 E/MainActivity: currrent String : 1 Service Test
03-12 04:27:43.435 E/MainActivity: Current Thread name: pool-1-thread-1
03-12 04:27:43.435 E/MainActivity: Current Thread is MainThread? : false
    
03-12 04:27:43.435 E/MainActivity: currrent String : 2 Service Test
03-12 04:27:43.435 E/MainActivity: Current Thread name: pool-1-thread-2
03-12 04:27:43.435 E/MainActivity: Current Thread is MainThread? : false
    
03-12 04:27:43.439 E/MainActivity: currrent String : 3 Service Test
03-12 04:27:43.439 E/MainActivity: Current Thread name: pool-1-thread-3
03-12 04:27:43.439 E/MainActivity: Current Thread is MainThread? : false

注意看时间和线程名字,可以看到他们几乎是同时执行的,而且各自运行在单独的线程之中。对比出来也比较明了了。

讲解完ThreadMode之后,@Subscribe还有其他两个属性

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;
    ...
    boolean sticky() default false; //是否是粘性操作
    ...
    int priority() default 0; //优先级
}
  • int priority:表示的是当前事件的优先级,设置该优先级的目的是,当一个事件有多个订阅者的时候,优先级高的会优先接收到事件。
 @Subscribe(threadMode = ThreadMode.MAIN ,priority = 0)
    public void priority0(String s){
        Log.e(TAG, "priority0: " + s );
    }

    @Subscribe(threadMode = ThreadMode.MAIN ,priority = 50)
    public void priority50(String s){
        Log.e(TAG, "priority50: " + s );
    }

    @Subscribe(threadMode = ThreadMode.MAIN ,priority = 100 )
    public void priority100(String s){
        Log.e(TAG, "priority100: " + s );
    }

发送一个事件之后,接受到的结果为

03-13 01:46:57.263 E/MainActivity: priority100: Service Test
03-13 01:46:57.263 E/MainActivity: priority50: Service Test
03-13 01:46:57.263 E/MainActivity: priority0: Service Test

如果此时去掉优先级的话,则顺序是无序的。

  • boolean sticky:表示的是粘性事件,类似于Android的粘性广播,通俗讲就是当你发送事件的时机比注册时机早的时候,如果设置了sticky粘性,则可以在发送事件完毕后再注册,也可以收到事件,但对于同种事件类型(参数类型)的话只会接受到最近发送的粘性事件,以前的不会收到。我们来验证一下。
   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EventBus.getDefault().postSticky("Stick Event 1");
        EventBus.getDefault().postSticky("Stick Event 2");
        EventBus.getDefault().postSticky(10);
        EventBus.getDefault().postSticky(20);
    }
    
    @Subscribe(threadMode = ThreadMode.MAIN , sticky = true)
    public void receiveEventString(String s){
        Log.e(TAG, "receiveEventString: " + s );
    }
    @Subscribe(threadMode = ThreadMode.MAIN , sticky = true)
    public void receiveEventInt(Integer i){
        Log.e(TAG, "receiveEventInt: " + i );
    }

可以看到这里注册的时机是在按钮点击之后,但之前消息已经是发送出去了。此时点击注册后,可以看到输出结果

E/MainActivity: receiveEvent: Stick Event 2
E/MainActivity: receiveEventInt: 20

粘性事件的内部,则是用了一个Map在保存这些粘性事件,而key则是这些粘性事件的参数类型,所以对于同个参数类型的话,最终只会保存最近那个使用的。

 public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

粘性事件的发送必须满足
* 发送事件必须是EventBus.getDefault().postSticky
* 方法的注解要设置stick = true,而这个默认值则为false

四.小结

  • EventBus在3.0版本可说是做了大改,很多之前版本一些缺点都做了改正,提供了注解,性能有了很大的提升,其实是提供了4种ThreadMode来适应不同的网络情况,相比于Otto来说EventBus的网络请求功能更加丰富

  • ThreadMode.POST:代表这个方法会在当前发布事件的线程执行,也就是执行事件和发送事件都在同一个线程中。(默认是这个)

  • ThreadMode.MAIN:代表这个方法会在主线程执行

  • ThreadMode.BACKGROUND:如果发送事件的线程不是UI线程,则运行在该线程中。如果发送事件的是UI线程,则它运行在由EventBus维护的一个单独的线程池中,事件会加入后台任务队列,使用线程池一个接一个调用。

  • ThreadMode.ASYNC:运行在单独的工作线程中,不论发送事件的线程是否为主线程。跟BackgroundThread不一样,该模式的所有线程是独立的,因此适用于长耗时操作,例如网络访问。它也是使用线程池调用,注意没有BackgroundThread中的一个接一个。

参考资料

源码解析
Web note ad 1