Android EventBus 3.0.0 使用总结

最新推荐文章于 2021-05-26 13:47:51 发布
最新推荐文章于 2021-05-26 13:47:51 发布
阅读量757 收藏
点赞数
文章标签： android 框架 EventBus 事件总线 赵彦军
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoyanjun6/article/details/53065112
版权

转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/53065112
本文出自【赵彦军的博客】

前言

  • EventBus框架

    EventBus是一个通用的叫法，例如Google出品的Guava，Guava是一个庞大的库，EventBus只是它附带的一个小功能，因此实际项目中使用并不多。用的最多的是greenrobot/EventBus，这个库的优点是接口简洁，集成方便，但是限定了方法名，不支持注解。另一个库square/otto修改自 Guava ，用的人也不少。所以今天我们研究的目标是greenrobot的EventBus.

  • EventBus 简介

    1、EventBus3.0.0 是最新的版本。
    2、EventBus 是Android 发布/订阅事件总线，可简化 Activities, Fragments, Threads, Services 等组件间的消息传递。
    3、可替代 Intent, Handler, BroadCast ，接口等传统方案，更快，代码更小，50K 左右的 jar 包，代码更优雅，彻底解耦。

    github地址：https://github.com/greenrobot/EventBus

EventBus原理图

这里写图片描述

如何添加依赖

  • 在module的build.gredle 文件中的dependencies标签中添加

    compile ‘org.greenrobot:eventbus:3.0.0’

    例如

 apply plugin: 'com.android.application'

android {
    compileSdkVersion 24
    buildToolsVersion "24.0.3"

    defaultConfig {
        applicationId "com.eventbus.app"
        minSdkVersion 14
        targetSdkVersion 24
        versionCode 1
        versionName "1.0"

    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:24.2.1'

    compile 'org.greenrobot:eventbus:3.0.0'
}

如何使用

  • 注册事件

    EventBus.getDefault().register( this );

  • 取消注册

    EventBus.getDefault().unregister( this );

  • 发送数据

    EventBus.getDefault().post( “我发射了”);

简单小例子：使用EventBus传递简单字符串

package com.eventbus.app;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Toast;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //注册
        EventBus.getDefault().register( this );


        findViewById( R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBus.getDefault().post( "我发射了");
            }
        });
    }

    /**
     *  自定义一个方法 hello() ，用来接收事件。
     *  方法名字可以随便写
     * @return
     */

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void hello ( String event){
        /* Do something */
        Toast.makeText( this , event , Toast.LENGTH_SHORT).show();
    };


    @Override
    protected void onDestroy() {
        super.onDestroy();

        //取消注册 , 防止Activity内存泄漏
        EventBus.getDefault().unregister( this );
    }
}

效果图
这里写图片描述

线程模型

在接收事件消息的方法中，可以通过注解的方式设置线程模型，EventBus内置了4中线程模型，分别是ThreadMode.POSTING 、ThreadMode.MAIN、ThreadMode.BACKGROUND、ThreadMode.ASYNC

比如：

 @Subscribe(threadMode = ThreadMode.POSTING)
    public void onMessageEventPostThread(String event) {
        Log.e( "event PostThread", "消息： " + event + "  thread: " + Thread.currentThread().getName()  );
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEventMainThread(String event) {
        Log.e( "event MainThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onMessageEventBackgroundThread(String event) {
        Log.e( "event BackgroundThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void onMessageEventAsync(String event) {
        Log.e( "event Async",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

  • PostThread：如果使用事件处理函数指定了线程模型为PostThread，那么该事件在哪个线程发布出来的，事件处理函数就会在这个线程中运行，也就是说发布事件和接收事件在同一个线程。在线程模型为PostThread的事件处理函数中尽量避免执行耗时操作，因为它会阻塞事件的传递，甚至有可能会引起ANR。

  • MainThread：如果使用事件处理函数指定了线程模型为MainThread，那么不论事件是在哪个线程中发布出来的，该事件处理函数都会在UI线程中执行。该方法可以用来更新UI，但是不能处理耗时操作。

  • BackgroundThread：如果使用事件处理函数指定了线程模型为BackgroundThread，那么如果事件是在UI线程中发布出来的，那么该事件处理函数就会在新的线程中运行，如果事件本来就是子线程中发布出来的，那么该事件处理函数直接在发布事件的线程中执行。在此事件处理函数中禁止进行UI更新操作。

  • Async：如果使用事件处理函数指定了线程模型为Async，那么无论事件在哪个线程发布，该事件处理函数都会在新建的子线程中执行。同样，此事件处理函数中禁止进行UI更新操作。

小例子1： 在子线程发送数据

package com.eventbus.app;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //注册
        EventBus.getDefault().register( this );

        findViewById( R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Log.d( "event 发射数据线程 : " , Thread.currentThread().getName() ) ;
                        EventBus.getDefault().post( "我发射了");
                    }
                }).start() ;
            }
        });
    }


    @Subscribe(threadMode = ThreadMode.POSTING)
    public void onMessageEventPostThread(String event) {
        Log.e( "event PostThread", "消息： " + event + "  thread: " + Thread.currentThread().getName()  );
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEventMainThread(String event) {
        Log.e( "event MainThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onMessageEventBackgroundThread(String event) {
        Log.e( "event BackgroundThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void onMessageEventAsync(String event) {
        Log.e( "event Async",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();

        //取消注册 , 防止Activity内存泄漏
        EventBus.getDefault().unregister( this );
    }
}

运行结果：

D/event 发射数据线程 :: Thread-109
E/event BackgroundThread: 消息： 我发射了 thread: Thread-109
E/event PostThread: 消息： 我发射了 thread: Thread-109
E/event Async: 消息： 我发射了 thread: pool-1-thread-2
E/event MainThread: 消息： 我发射了 thread: main

小例子2： 在主线程发送数据

package com.eventbus.app;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //注册
        EventBus.getDefault().register( this );

        findViewById( R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d( "event 发射数据线程 : " , Thread.currentThread().getName() ) ;
                EventBus.getDefault().post( "我发射了");
            }
        });
    }

    @Subscribe(threadMode = ThreadMode.POSTING)
    public void onMessageEventPostThread(String event) {
        Log.e( "event PostThread", "消息： " + event + "  thread: " + Thread.currentThread().getName()  );
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEventMainThread(String event) {
        Log.e( "event MainThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onMessageEventBackgroundThread(String event) {
        Log.e( "event BackgroundThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Subscribe(threadMode = ThreadMode.ASYNC)
    public void onMessageEventAsync(String event) {
        Log.e( "event Async",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();

        //取消注册 , 防止Activity内存泄漏
        EventBus.getDefault().unregister( this );
    }
}

运行结果：

D/event 发射数据线程 :: main
E/event MainThread: 消息： 我发射了 thread: main
E/event PostThread: 消息： 我发射了 thread: main
E/event Async: 消息： 我发射了 thread: pool-1-thread-3
E/event BackgroundThread: 消息： 我发射了 thread: pool-1-thread-4

黏性事件

除了上面讲的普通事件外，EventBus还支持发送黏性事件。何为黏性事件呢？简单讲，就是在发送事件之后再订阅该事件也能收到该事件，跟黏性广播类似。具体用法如下：

  • 注册

    EventBus.getDefault().register( this );

  • 事件接收

    @Subscribe(threadMode = ThreadMode.MAIN , sticky = true )
    public void onMessageEventMainThread(String event) {
    Log.e( “event MainThread”, “消息： ” + event + ” thread: ” + > Thread.currentThread().getName());
    }

  • 取消注册

    EventBus.getDefault().unregister( this ) ;

  • 发送事件

    EventBus.getDefault().postSticky( “我发射了”);

小例子：在MainActivity发送事件，在Activity2里注册并且接收事件

MainActivity源码

package com.eventbus.app;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

import org.greenrobot.eventbus.EventBus;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        findViewById( R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d( "event 发射数据线程 : " , Thread.currentThread().getName() ) ;
                EventBus.getDefault().postSticky( "我发射了");

                startActivity( new Intent( MainActivity.this , Activity2.class ));
            }
        });
    }
}

Activity2源码

package com.eventbus.app;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

public class Activity2 extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_2);
        //注册
        EventBus.getDefault().register( this );
    }

    @Subscribe(threadMode = ThreadMode.MAIN  , sticky =  true )
    public void onMessageEventMainThread(String event) {
        Log.e( "event MainThread",  "消息： " + event + "  thread: " + Thread.currentThread().getName());
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //取消注册 , 防止Activity内存泄漏
        EventBus.getDefault().unregister( this ) ;
    }
}

这就是粘性事件，能够收到订阅之前发送的消息。但是它只能收到最新的一次消息，比如说在未订阅之前已经发送了多条黏性消息了，然后再订阅只能收到最近的一条消息。

EventBus源码分析

  • Subscribe 接口源码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;

    /**
     * If true, delivers the most recent sticky event (posted with
     * {@link EventBus#postSticky(Object)}) to this subscriber (if event available).
     */
    boolean sticky() default false;

    /** Subscriber priority to influence the order of event delivery.
     * Within the same delivery thread ({@link ThreadMode}), higher priority subscribers will receive events before
     * others with a lower priority. The default priority is 0. Note: the priority does *NOT* affect the order of
     * delivery among subscribers with different {@link ThreadMode}s! */
    int priority() default 0;
}

可以看出默认的线程模型是ThreadMode.POSTING ；默认黏性事件为false,也就是默认不开启黏性事件；默认的优选级为0 。

  • EventBus 类部分源码
  static volatile EventBus defaultInstance;

   /** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

getDefault() 是一个单例模式 , 只有一个实例对象。

  • ThreadMode 类源码
public enum ThreadMode {

    /**
     * Subscriber will be called in the same thread, which is posting the event. This is the default. Event delivery
     * implies the least overhead because it avoids thread switching completely. Thus this is the recommended mode for
     * simple tasks that are known to complete is a very short time without requiring the main thread. Event handlers
     * using this mode must return quickly to avoid blocking the posting thread, which may be the main thread.
     */

    POSTING,

    /**
     * Subscriber will be called in Android's main thread (sometimes referred to as UI thread). If the posting thread is
     * the main thread, event handler methods will be called directly. Event handlers using this mode must return
     * quickly to avoid blocking the main thread.
     */

    MAIN,

    /**
     * Subscriber will be called in a background thread. If posting thread is not the main thread, event handler methods
     * will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single
     * background thread, that will deliver all its events sequentially. Event handlers using this mode should try to
     * return quickly to avoid blocking the background thread.
     */

    BACKGROUND,

    /**
     * Event handler methods are called in a separate thread. This is always independent from the posting thread and the
     * main thread. Posting events never wait for event handler methods using this mode. Event handler methods should
     * use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number
     * of long running asynchronous handler methods at the same time to limit the number of concurrent threads. EventBus
     * uses a thread pool to efficiently reuse threads from completed asynchronous event handler notifications.
     */

    ASYNC
}

这个类是枚举类，定义了线程模型中的几种类型。

个人公众号，欢迎关注

这里写图片描述

参考资料

【EventBus 3.0的用法详解】
【EventBus使用详解】
【腾讯Bugly干货】老司机教你“飙”EventBus3】

赵彦军
关注
专栏目录
eventbus-3.0.0.jar
06-21
eventbus-3.0.0.jar eventbus-3.0.0.jar eventbus-3.0.0.jar
eventBus 3.0.0的jar包
01-29
EventBus 3.0.0Jar包. EventBus是Android中组件与组件之间通信的框架，可以解耦和简化Activity与Activity、Activity和Fragment、Fragment和Fragment之间的通信。
android EventBus 3.0
weixin_36965072的博客
07-30 1137
项目地址: github 地址 eventBus能做什么?为我们解决什么问题? 1.通信,各组件信息的传递,而且是在任何时候,信息内容可以是简单的标识,也可以是json数据,等; 2.项目中总有两个组件藕断丝连,甚至完全不搭边;但是从业务逻辑上,界面显示上做同步处理; 这个时候 eventBus 出场了;使用其他方法代码臃肿,可读性差的自己都不想看;而eve...
Android EventBus 3.0.0深度剖析与实战指南
本文将为您详细介绍 EventBus 的使用总结，特别适合那些想要提升 Android 应用开发效率和代码组织的朋友。 EventBus 是一个轻量级且易于集成的事件发布/订阅机制，旨在替代传统的 Intent、Handler、Broadcast 和...
绿色机器人EventBus 3.0.0：Android消息传递神器总结
本文将详细介绍greenrobot/EventBus 3.0.0在Android开发中的应用，这是一种流行的事件总线框架，用于简化不同组件间的通信，如Activities、Fragments、Threads和Services。与传统的Intent、Handler和Broadcast等解决...
EventBus3.0.0了解及使用
zrh528的博客
06-21 606
github：https://github.com/greenrobot/EventBus app依赖库：compile 'org.greenrobot:eventbus:3.0.0' 一、概述 因为EventBus3.0.0跟以前的版本使用方法略有不同，所以在这记录一下。 二、了解及使用 1、定义一个消息类 public class OneEventBean { pri
EventBus3.0.0的使用
gmc940103的博客
12-01 339
在开发过程中，我们有时会遇到需要发消息通知的地方，有的人选择使用广播发送，这是系统自带的，这里有一个jar包提供了这种功能，这个就是EventBus。 以下是使用方法。 1，首先定义一个用来区别接收的类。 public class EventBusAction { //活动详情关注改变，通知刷新列表 public static String EVENTBUS_ACTIO
EventBus3.0jar包
05-22
这个是EventBus3.0 的jar包，如果还使用elipse可以用这个，导入到lib包下即可
EventBus系列：EventBus3.0 简单使用
知道这个有什么用？
05-13 163
上效果： 先引入EventBus依赖： implementation 'de.greenrobot:eventbus:3.0.0-beta1' 需要接受信息的Acitivity, 注册EventBus，并在onDestroy()中解除。 public class MainActivity extends AppCompatActivity { TextView tvName; @Override protected void onCreate(Bundle savedIn
【Android】EventBus 3.0 源码分析
Mlib
09-30 1563
概述EventBus是一个基于观察者模式的事件发布/订阅框架，开发者可以通过极少的代码去实现多个模块之间的通信，既可用于 Android 四大组件间通讯，也可以用于异步线程和主线程间通讯，而不需要以Interface回调、handler或者BroadCastReceiver的形式去单独构建通信桥梁。从而降低因多重回调导致的模块间强耦合，同时避免产生大量内部类。这是EventBus源码中的介绍：/**
EventBus3.0详解
weixin_33980459的博客
06-01 174
2019独角兽企业重金招聘Python工程师标准>>> ...
安卓EventBus3.0使用讲解(一)
Allan的博客
05-29 642
什么是EventBus 　　EventBus是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。 基本用法 　　很多文章会讲到Subscri
Android消息传递之EventBus 3.0使用与案例
Sahara_Savage
12-09 2495
转载请标明出处：http://blog.csdn.net/donkor_/article/details/53534922 前言： greenrobot的EventBus的大名不必多说，在实际项目开发中，使用起来既简单又方便，所以决定写下这篇文章，一方面是总结，一方面是给需要的人看看。目前EventBus最新版本是3.0，所以以下所讲内容都是基于EventBus3.0。相似的产品还有squ...
Android EventBus3.0使用及源码解析
一口仨馍
07-10 8091
本文已授权微信公众号《非著名程序员》原创首发，转载请务必注明出处。 # EventBus3.0简介 `EventBus`是greenrobot出品的一个用于Android中事件发布/订阅的库。以前传递对象可能通过接口、广播、文件等等，尤其像同一个`Activity`两个`Fragment`之间采用接口传递对象，十分的麻烦，而且耦合度较高。使用`EventBus`之后，这些将不再是问题。
android3.0版本,Android---EventBus3.0版本的使用及说明
weixin_32873435的博客
05-26 299
EventBus3.0事件介绍EventBus是一个基于观察者模式，并且是针对了Android进行优化的发布/订阅的事件总线。简化了应用程序内各组件间、组件与后台线程间的通信。优点是开销小，代码更优雅，以及将发送者和接收者解耦，避免了产生大量的内部类。EventBus3.0应用的范围比较广，比如请求网络，当请求网络后，可以通过handler和broadcast通知UI，同样也可以使用EventBu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值