Android——GT.EventBus 跨进程全面解析教程

PlayfulKing

已于 2023-11-22 22:05:02 修改

阅读量7k

点赞数 5

分类专栏： GT使用教程 Android 文章标签： android

于 2022-03-31 20:46:19 首次发布

本文链接：https://blog.csdn.net/qq_39799899/article/details/123871288

版权

GT使用教程同时被 2 个专栏收录

21 篇文章 8 订阅

订阅专栏

Android

21 篇文章 5 订阅

订阅专栏

前言

GT库,终于出传递数据的新框架了.目前将这个传递数据的新框架命名为 GT.EventBus
里面核心实现原理与市面上流行的 EventBus 是一样的,在功能上有细微差别,功能上进行了史诗级增强.且支持跨进程传递数据

EventBus也有很明显的缺陷，在EventBus中事件的分发是通过注解函数的参数类型确定的，因此在事件发布遭到大量滥用时，特别有多个订阅者、多个相同参数时，很难从事件发布者开始理清消息流，无法快速的找出是哪个订阅者接受并处理了消息导致的问题，这就要求了参与者必须对整个通知过程有着良好的理解。当程序代码适量时，这是一个合理的要求，然而当程序太大时，这将成为一种负担。在EventBus中一定要写好必要的注释信息，否则在后续工作交接中会产生很多不必要的麻烦。
现在我们来简单介绍一下 GT.EventBus

前言

GT库,终于出传递数据的新框架了.目前将这个传递数据的新框架命名为 GT.EventBus里面核心实现原理与市面上流行的 EventBus 是一样的,在功能上有细微差别,功能上进行了史诗级增强.且支持跨进程传递数据

GT.EventBus 与 EventBus 使用区别:

简单介绍 GT.EventBus:

GT.EventBus有三个主要的元素需要我们先了解一下:

Event:事件,可以是任意类型的对象或字符

依赖GT库

在使用GT库里封装的架构当然需要先依赖好GT库:

GT.EventBus 与 EventBus 使用区别:

        (1).(最大的区别)发布事件时无需定义事件类,GT.EventBus取消了EventBus发布事件是必须通过事件类来发布事件的规则,采用更为灵活的发布方式,自定义区域到点,进行发布事件(后面会详细介绍到),解决了原版EventBus中在多订阅者且同参数时,很难从时间发布者理清消息流与无法快速找出是哪个订阅者处理消息的问题
        (2).发布事件后若订阅者有返回值,则发布事件可以获取到该返回值(但有线程限制,内部是用线程池管理的)
        (3).可以为同一事件设置不同的事件标识 eventKey 可以更为精准的发布事件让订阅者接收到

(4).支持查看普通事件,查看粘性事件,删除单个粘性事件,清空粘性事件等等些功能方法

(5).GT.EventBus支持跨进程传输，而原版的EventBus并不支持

(6).暂不支持遍历父类继承制订阅者,在后面可能会完善这个

简单介绍 GT.EventBus:

GT.EventBus 是一款针对Android优化的发布/订阅事件总线.简化了应用程序内各组件间、组件与后台线程间的通信.优点是开销小,代码更优雅,以及将发送者和接收者解耦.
在我们之前的Activity 与 Activity 之间传递数据是可以用到我们常用的Intent,Bundle等等,
如果Fragment和Fragment进行交互那就有些麻烦,需要从相应的Activity中通过tab等获取Fragment引用再进行获取数据,
或者我们也会使用广播来处理,比如GT库之前出过一个GT.DataSendReception框架这里面用的核心原理就是通过广播进行传递数据,但是使用广播那就离不开Activity,稍显麻烦,但这两种数据传递框架各有千秋，

如果传递的数据是实体类需要序列化,那么很显然成本会有点高.今天我们就来学习下GT.EventBus的使用方法.

GT.EventBus有三个主要的元素需要我们先了解一下:

Event:事件,可以是任意类型的对象或字符

事件订阅者,Subscriber:

eventKey-(新特性-不懂没关系,后面会有图文介绍)
    * 指定订阅者key标签,若不指定则默认为该方法名为订阅者key标签
        * 注意:在自定义 evenKey 时请不要写入 "_GT_" 字符,该字符为关键字
         * 彩蛋发布事件后可接收到订阅者返回值,但如果订阅者与发布者不在同一线程中或发布的事件中有两个订阅者,将无法在发布事件的线程接收到订阅者的返回值
             *
             * 发布事件方式一:纯 eventData
             * 将该事件发布到整个订阅者管理器
             *
             * 发布事件方式二:纯 String
             * 单个 String表示,在所有注册的区域里匹配到这 eventKey 唯一标识,并发布事件
             * 多个 String表示,在所有注册的区域里匹配这多个eventKey 唯一标识,并发布事件
             *
             * 发布事件方式三:纯 Class
             * 单个 Class表示,在当前Class类中找到被 Subscribe注解标识过的所有方法进行"参数匹配试"发布事件
             * 多个 Class表示,在这些Class类中找到被 Subscribe注解标识过的所有方法进行"参数匹配试"发布事件
             *
             * 发布事件方式四:String 与 Class 混合类型,混合的顺序可顺便(但在删除粘性事件时的key必须与发布事件的key一模一样,包括字母顺序)
             * 单组混合类型表示,在这 class 中寻找到该 eventKey 名称的方法进行发布事件
             * 多组混合类型表示,在这些 class 中寻找到这些 eventKey 名称的方法进行发布事件

五种线程模型分别为，threadMode-

         (1)POSTING(默认): 在当前线程处理事件
         (2)MAIN: 若发布事件为主线程,那就在该主线程上处理,否则切换到主线程处理
(3)MAIN_ORDERED: 不管在那个线程上,直接切换到主线程处理事件
(4)BACKGROUND: 若发布事件时为子线程,那就在该子线程处理,否则new子线程处理
         (5)ASYNC:不管在那个线程上,new一个子线程处理

是否支持粘性事件，默认为falsesticky:

可以让事件，先发布，后接收的机制。

订阅方法优先级默认为0，priority:

多个事件订阅方法可以接收相同的事件，
在发布事件后,订阅者无需切换线程的情况下,优先级高的先接收到事件,若发布事件时订阅者会切换线程则不会保证优先级高的先接收到事件

取消事件分发，cancelEventDelivery:

一旦取消了事件的分发，事件将不再继续向下进行分发，一般和订阅方法优先级互相配合，可以通过优先级+取消事件分发构建拦截链。

事件发布者，Publisher:

可以在任意线程任意位置发送事件,直接调用GT.EventBus的post(Object)方法.可以自己实例化 GT. EventBus对象,但一般使用GT.EventBus.getDefault()就好了,
根据post函数参数的类型,会自动调用订阅相应类型事件的函数.

跨进程传递数据，postAcrossProcessess：

在新版本v1.4.2.4版本以及之后的版本，均支持多进程传递数据

依赖GT库

在使用GT库里封装的架构当然需要先依赖好GT库:

详细依赖教程请参看

GitHub - 1079374315/GTContribute to 1079374315/GT development by creating an account on GitHub.https://github.com/1079374315/GT

接下来我们就来看看 GT.EventBus 基本用法,其实用法和市面上流行的 EventBus 几乎没区别,只是加上 GT. 引用的

public class MainActivity extends AppCompatActivity {
    private TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.tv);
        tv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //发送事件
                GT.EventBus.getDefault().post("GT库不止这一个好用的框架!");
            }
        });
        //注册订阅者
        GT.EventBus.getDefault().register(this);
    }
    //处理事件
    @GT.EventBus.Subscribe
    public void demo(String name){
        tv.setText(name);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //取消注册订阅
        GT.EventBus.getDefault().unregister(this);
    }
}

效果图:

瞧GT.EventBus 与 EventBus的使用是不是几乎没啥区别,只有在发布事件与处理事件的参数上有所区别,这是因为 GT.EventBus 与 EventBus 最大的区别就是 GT.EventBus 取消了 EventBus发布事件是必须通过事件类来发布事件的规则,采用更为灵活的发布方式,自定义区域到点,进行发布事件

接下来我们来看看既然取消的 必须事件类 的规则那GT.EventBus 又是采用什么方式来发布事件

我们先来看看 post 参数规则

 /**
   * TODO 注意:在自定义 evenKey 时请不要写入 "_GT_" 字符,该字符为关键字
   * TODO 彩蛋 发布事件后可接收到订阅者返回值,但如果订阅者与发布者不在同一线程中或
   *     发布的事件中有两个订阅者,将无法在发布事件的线程接收到订阅者的返回值
   *
   * 发布事件 方式一:纯 eventData
   * 将该事件发布到整个 订阅者管理器
   * <p>
   * 发布事件 方式二:纯 String
   * 单个 String表示,在所有注册的区域里匹配到这 eventKey 唯一标识,并发布事件
   * 多个 String表示,在所有注册的区域里匹配这 多个eventKey 唯一标识,并发布事件
   * <p>
   * 发布事件 方式三:纯 Class
   * 单个 Class表示,在当前Class类中找到被 Subscribe注解标识 
   * 过的所有方法进行"参数匹配试"发布事件
   * 多个 Class表示,在这些Class类中找到被 Subscribe注解标识 
   * 过的所有方法进行"参数匹配试"发布事件
   * <p>
   * 发布事件 方式四:String 与 Class 混合类型,混合的顺序可顺便
   * (但在删除粘性事件时的key必须与发布事件的key一模一样,包括字母顺序)
   * 单组 混合类型表示,在这 class 中 寻找到 该 eventKey 名称的方法进行发布事件
   * 多组 混合类型表示,在这些 class 中 寻找到 这些 eventKey 名称的方法进行发布事件
   * <p>
   */

这就是 evenKey 参数的规则了,看不懂没关系,我们先深入看看post看看参数

参数一:Object EventData

发布的事件 (参数仅支持一个,若需要传多参数可传递 Bundle,List,Map,实体类Bean等等)

参数二:Object... eventKeys

指定发送的区域 (如果不填则默认向所有订阅者发布事件)

我们之前发布事件的方式只填了 eventData 参数,所以就是按照第一种发布方式来向所有订阅者发布的事件的

 //发布事件 方式一:纯 eventData,将该事件发布到整个 订阅者管理器
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!");

那发布全局是啥样效果?我们来看张图

绿色线是可以接收到的,而红色线因为参数类型不同,所以接收不到.

那我们想单独给其中一个的方法发布事件,不想全部都发怎么办?

那我们就需要用到第二种发布事件的方法了

 //发布事件 方式二:纯 String
 //单个 String表示,在所有注册的区域里匹配到这 eventKey 唯一标识,并发布事件
 //多个 String表示,在所有注册的区域里匹配这 多个eventKey 唯一标识,并发布事件
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!","demo");

添加一个方法名就可以了.那我们想给这三个方法中其中两个方法进行发布事件呢,只需要在demo后面再加上发布事件的方

 //发布事件 方式二:纯 String
 //单个 String表示,在所有注册的区域里匹配到这 eventKey 唯一标识,并发布事件
 //多个 String表示,在所有注册的区域里匹配这 多个eventKey 唯一标识,并发布事件
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!","demo","aaa");

是不是很简单呢,可以好好理解一下代码上注释的发布事件规则

细心的小伙伴有没有想到,因为是全局发布的,所以要是其他Activity或页面有相同的方法名与参数,那我只想发MainActivity 不想发 MainActivity2 里的方法,咋搞?

使用第三种发布事件方法:0

 //发布事件 方式三:纯 Class
 //单个 Class表示,在当前Class类中找到被 Subscribe注解标识,过的所有方法进行"参数匹配试"发布事件
 //多个 Class表示,在这些Class类中找到被 Subscribe注解标识,过的所有方法进行"参数匹配试"发布事件
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!", MainActivity.class);

效果图:

日志:

GT_i: com.example.myapplication.(MainActivity.java:32) demo(): 接收到:GT库不止这一个好用的框架!
GT_i: com.example.myapplication.(MainActivity.java:38) aaa(): 接收到:GT库不止这一个好用的框架!

看,MainActivity 里的demo()方法与 aaa()方法都被调用并且收到事件了,那bbb()方法为啥没收到事件呢?因为bbb()方法的参数类型不同,所以事件不会发布给bbb()方法的

问题:那我只想在MainActivity2 精准发布事件到 MainActivity 里的demo方法,不想有其他任何方法接收到该事件咋办?

那咋们就可以用到第四种发布事件的方式了

 //发布事件 方式四:String 与 Class 混合类型,在发布事件时的混合类型顺序可顺便
 //(但在删除粘性事件时的key必须与发布事件的key一模一样,包括字母顺序)
 //单组 混合类型表示,在这 class 中 寻找到 该 eventKey 名称的方法进行发布事件
 //多组 混合类型表示,在这些 class 中 寻找到 这些 eventKey 名称的方法进行发布事件
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!", MainActivity.class, "demo");

效果图:

日志:

com.example.myapplication.(MainActivity.java:32) demo(): 接收到:GT库不止这一个好用的框架!

这样咋们就做到了精准发布事件了,到此你以为GT.EvenBus的发布事件就这些吗?还有一个更加便捷的自定义发布事件标识,可以让你给特殊的方法特殊化,

我们将MainActivity里的 demo方法加上一个标签为 "GT"

然后我们再在MainActivity2里去精准发布事件试试

效果图

是的,发现MainActivity2发布的事件MainActivity里的demo方法没有收到

我们来点开那个 (eventKey = "GT") 参数看看啥原因

难怪,之前我们没有设置这个值,所以GT.EventBus默认将我们类里的方法名设置给 eventKey当做标识了,这下我们手动设置了这个标识,意味着我们发布事件想发布到这个方法来也需要按照新设置的 eventKey标识来发布,

我们来改一下发布事件的代码:

修改处:

 //发布事件 方式四:String 与 Class 混合类型,在发布事件时的混合类型顺序可顺便
 //(但在删除粘性事件时的key必须与发布事件的key一模一样,包括字母顺序)
 //解释:向MainActivity.class类中的 GT 标识发布事件,传递的参数类型为String
 GT.EventBus.getDefault().post("GT库不止这一个好用的框架!", MainActivity.class, "GT");

再来看看效果图:

获取订阅者返回值

接下来我们来学一个非常有用有趣的功能,获取到订阅者执行完后返回的数据

原版的EventBus可不支持这个哦,这是GT.EventBus特有的功能

我们先看看订阅者这边返回数据的代码:

再来看看发布事件者如何接收订阅者返回的数据:

效果图:

是不是很神奇,就是直接在发布事件者后面接收参数就是订阅者的返回值了,但这个接收参数是有条件的,如果同时有10多个订阅者都返回参数,那我们该接收那个?

所以接收订阅者返回参数的条件是:

发布事件后可接收到订阅者返回值,但如果订阅者与发布者不在同一线程中或发布的事件中有多个订阅者同时返回,将无法在发布事件的线程接收到订阅者的返回值

GT.EventBus虽然取消了必须用事件类的规则,但同时也支持使用事件类,这下果然发布事件接收成功了!

使用事件类演示

订阅者事件类

发布事件类

效果图:

日志:

com.example.myapplication.(MainActivity.java:25) bbb(): 接收到:MessageBean{data='我是 Activity2'}
(MainActivity2.java:19): 订阅者返回的值:MessageBean{data='我收到了:我是 Activity2'}

非常好,你如果看到这你已经把GT.EventBus 与 EventBus 的区别之处全部学的差不多了,后面讲的将会是 订阅者线程 , 订阅者方法优先级 , 订阅者支持粘性事件 , 发布粘性事件 , 删除单个粘性事件 , 清空所有粘性事件 , 这些,如果你都会下面的可以忽略不看了.

需要跳过的同学,后面讲解的区别可以参考下面的图片

之前还没用过EventBus 的同学接下来我们再来学习一下订阅者线程的处理

五个线程事件处理:

POSTING:在当前线程处理发布的事件

MAIN:若发布事件时为(UI)主线程,那就在发布事件的主线程上处理,否则新new一个主线程处理

MAIN_ORDERED:直接new一个主线程处理

BACKGROUND:若发布事件时为子线程,那就在发布事件的子线程上处理,否则新new一个子线程处理

ASYNC:直接new一个子线程处理

我们来看一张图片你就明白了

这里简单的介绍了三种线程使用的方法后作用,后面的两种看意思理解就可以了

注意如果在子线程里不小心更新了UI,其实是会报错的,但GT.EventBus帮咋们把错误给捕获封装了,所以在线程处理上,尽量是什么线程干什么活.

订阅者方法优先级

代码实际编写

最终效果图:

日志:

com.example.myapplication.(MainActivity.java:29) demo(): 接收到:GT库不止这一个好用的框架!
com.example.myapplication.(MainActivity.java:39) bbb(): 接收到:GT库不止这一个好用的框架!
com.example.myapplication.(MainActivity.java:34) aaa(): 接收到:GT库不止这一个好用的框架!

看图加效果图,是不是一下就懂了,但需要注意这里方法优先级的规则注释

在同一线程发布事件不需要切换线程执行事件的情况下是保证优先级顺序的,如果是切换了线程执行的,那就不保证了.

支持粘性事件

所谓的粘性事件就是，先发送事件，订阅者后接收，而发布粘性事件与发布普通事件用法是只是调用的方法名变了,其余的都一样

 //发送普通事件
  GT.EventBus.getDefault().post(new LoginBean(user, pass), "getUserPass");

 //发送粘性事件
  GT.EventBus.getDefault().postSticky(new LoginBean(user, pass), "getUserPass");

我用一个登录页面来演示一下

登录页面代码：

public class MainActivity extends AppCompatActivity {

    private EditText et_user;
    private EditText et_pass;

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

        et_user = findViewById(R.id.et_user);
        et_pass = findViewById(R.id.et_pass);

        findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String user = et_user.getText().toString();
                String pass = et_pass.getText().toString();
                //...省去登录成功判断条件
                Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
                //发送粘性事件
                GT.EventBus.getDefault().postSticky(new LoginBean(user, pass), "getUserPass");
                startActivity(new Intent(MainActivity.this, MainActivity2.class));
            }
        });

    }

}

我们直接发送事件的页面是不需要写注册订阅者与取消订阅者的，登录页面获取用户输入的账号密码，判断正确后显示登录成功，将账号发送到粘性事件中，

这时我们指定发送的区域是 getUserPass 也就是说，只要后面打开的页面里或者类里，有符合 getUserPass 这个区域的方法，那么会自动调用该方法并赋值过去。这里的发送事件规则 postSticky 其实与 post 是一摸一样的，只不过 postSticky 是支持粘性事件的而已，发送规则与 post 一样。

我们再来看接收粘性事件是咋样的

public class MainActivity2 extends AppCompatActivity {

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

    //支持粘性事件
    @GT.EventBus.Subscribe(sticky = true)
    public void getUserPass(LoginBean loginBean) {
        GT.logt("收到登录的账号:" + loginBean);
        TextView textView = findViewById(R.id.tv_title);
        textView.setText("收到登录的账号:\n" + loginBean.getUser() + "\n" + loginBean.getPass());
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注册订阅者
        GT.EventBus.getDefault().unregister(this);
    }
}

只有接收方才需要 注册订阅者 与 取消订阅者 ，注意这个类的方法名 getUserPass 而且参数也是一样的 这就能保证会收到数据，getUserPass 方法会在注册订阅者的时候调用。、

取消事件分发

之前是有记录要做这个功能的，想在忙完工作之后再补上这个功能，但到最后忘了，目前在V1.4.2.2版本之上补上，在这里要先感谢我的好友粉丝，提醒博主忘记把这个功能写上。接下来咋们来看看，取消事件分发是咋样的。

GT库的 取消事件分发与原版是有所不同的，但也别当心，使用比原版只会简单不会复杂，

GT库为简单而生！

一旦取消了事件的分发，事件将不再继续向下进行分发，一般和订阅方法优先级互相配合，可以通过优先级+取消事件分发构建拦截链。

我们分别建两个类，MainActivity.class 与 MainActivity2.class

然后分别在不同的类里写上两个相同的订阅者 aaa

虽然两个类中都有订阅者 aaa ，但我们是从 MainActivity 跳转到 MainActivity2 再在 MainActivity2里的进行单击发布事件的。

我们看看这样发布的事件，默认的顺序如何：

先执行的是 MainActivity2 的订阅者 aaa，让后再执行的 MainActivity 的订阅者 aaa,

也就是说，在发布事件中，若有相同的订阅者 GT.EventBus 默认的顺序是先发送本类中的订阅者，再发送别类订阅者。

如果有需求想， MainActivity1、MainActivity2、MainActivity3、MainActivity4、MainActivity5 中都有订阅者 aaa ,我本来发布一则事件的执行顺序为 1/2/3/4/5，然后因为特殊原因，需要把这个发布的事件消耗在 3 怎么做呢？这时就可以使用取消事件分发的机制来实现

加上这个取消事件分发后，执行日志如下：

执行到 MainActivity2 后，这则发布的事件就被拦截下了。这还只是最基础的拦截手段，既然博主开头就说到，GT.EventBus 的拦截与原版有所不同，那接下来咋们就看看到底有那些不同，

原版：以形参作为拦截方式

@Subscribe
public void onEvent(MessageEvent event){
    EventBus.getDefault().cancelEventDelivery(event) ;
}

GT库版：五种拦截方式，灵活多变，具体拦截方式可以根据你自己需要的使用场景进行灵活调用

是不是使用起来很简单，取消事件分就介绍到这里了。

跨进程传递数据

这是 GT.EventBus v1.4.2.4版本以及之后的版本才支持的功能，让跨进程传递数据轻松实现。

我们先看看AndroidManifest.xml

<application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyApplication"
        tools:targetApi="31">

        <!-- 跨进程 Activity -->
        <activity
            android:name=".MainActivity2"
            android:exported="false"
            android:launchMode="singleTask"
            android:process=":process.unity"/>

        <!-- 非跨进程 Activity -->
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>

示意图:

MainActivity代码：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        GT.logt("创建 非跨进程");
        //注册事件
        GT.EventBus.getDefault().register(this);

        findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //跳转会非跨进程 Activity
                startActivity(new Intent(MainActivity.this, MainActivity2.class));
            }
        });

        findViewById(R.id.tv2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //向 MainActivity 发送数据
                GT.EventBus.getDefault().postAcrossProcesses("跨进程，你好呀", "readData2");
            }
        });
    }

    @GT.EventBus.Subscribe
    public void readData1(String msg) {
        GT.logt("读取到：" + msg);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //取消注册简洁版
        GT.EventBus.getDefault().unregister(this);
    }

}

MainActivity2代码:

public class MainActivity2 extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        GT.logt("创建 跨进程");
        //注册 跨进程Activity
        GT.EventBus.getDefault().registerAcrossProcesses(this);

        findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startActivity(new Intent(MainActivity2.this, MainActivity.class));//跳转会非跨进程 Activity
            }
        });

        findViewById(R.id.tv2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                GT.EventBus.getDefault().postAcrossProcesses("你好，我收到了你的消息", "readData1");//向 MainActivity 发送数据
            }
        });
    }
    @GT.EventBus.Subscribe
    public void readData2(String msg) {
        GT.logt("读取到：" + msg);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        GT.EventBus.getDefault().unregisterAcrossProcesses(this);//取消跨进程注册
    }
}

这个跨进程传递数据，实现起来够简单吧。

订阅与发布局部事件：

public class MainActivity extends AppCompatActivity {

    public final static String EVENT_BUS_AA = "EVENT_BUS_AA";//定义局部事件关键字

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

        //定义局部订阅事件
        GT.EventBus.registerInteriors(this, MainActivity.EVENT_BUS_AA, new GT.OneListener<String>() {
            @Override
            public void onOneListener(String name) {
                super.onOneListener(name);
                GT.logt("接受到发送的消息:" + name);
            }
        });

        findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //发布局部事件
                GT.EventBus.postInteriors("名字", MainActivity.EVENT_BUS_AA);
            }
        });

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //取消当类的局部事件
        GT.EventBus.unregisterInteriors(this);
    }
}

局部事件，非常简单灵活

当然还有些比较实用的方法如:

其他使用 API 功能：

    //注册简介版
    GT.EventBus.registers(this);

    //取消注册简洁版
    GT.EventBus.unregisters(this);

    //注册 跨进程Activity 简洁版
    GT.EventBus.registerAcrossProcessess(this);

    //取消跨进程注册 简洁版
    GT.EventBus.unregisterAcrossProcessess(this);

    //发布事件 简洁版
    GT.EventBus.posts("发送的内容","发送的目的地");

    //发布粘性事件 简洁版
    GT.EventBus.postStickys("发送的内容","发送的目的地");

    //发布跨进程事件 简洁版
    GT.EventBus.postAcrossProcessess("发送的内容","发送的目的地");

    //发布本进程 与 跨进程事件 简洁版
    GT.EventBus.postAlls("发送的内容","发送的目的地");

 /**
         * 删除单个 粘性事件
         *
         * @param eventKeys 填写的 key 必须要与发布事件的 key 一模一样,包括字母顺序
         */
        public boolean removeStickyEvent(Object... eventKeys)

/**
         * 清空粘性事件
         */
        public void clearStickyEvent()

 /**
         * 查看普通事件
         */
        public void showEventBusMap() {

 /**
         * 查看粘性事件
         */
        public void showEventBusStickyMap()

以上就是目前 GT.EventBus 核心功能的使用教学了，有什么特别好的建议都可以在评论区留言哦。

点个关注点个赞呗(〃'▽'〃) 关注博主最新发布库：GitHub - 1079374315/GT

PlayfulKing

关注

5
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
3
评论
Android——GT.EventBus 跨进程全面解析教程

目前将这个传递数据的新框架命名为 GT.EventBus里面核心实现原理与市面上流行的 EventBus 是一样的,在功能上有细微差别,功能上进行了史诗级增强.且支持跨进程传递数据
复制链接

扫一扫