Android事件总线

Android事件总线还能怎么玩？

顾名思义，AndroidEventBus （ github链接 ，关于我为什么要写这个库请参考《AndroidEventBus ( 事件总线 ) 的设计与实现》）是一个Android平台的事件总线框架，它简化了Activity、Fragment、Service等组件之间的交互，很大程度上降低了它们之间的耦合，使我们的代码更加简洁，耦合性更低，提升了我们的代码质量。但它能做的却不仅限于这些。经过定制，它能完成很多有意思的功能，那么究竟该怎么做呢？就让我们一起往下看吧。

不堪回首的痛

首先，让我们先来看看这么一个场景：你是否在开发的过程中遇到过从Activity-A跳转到Activity-B，然后需要在Activity-B处理完某些工作之后回调Activity-A中的某个函数，但Activity又不能手动创建对象来设置一个Listener的情况？或者遇到在某个Service中更新Activity或Fragment中的界面等组件之间的交互问题……

一经思考，你会发现Android中的Activity、Fragment、Service之间的交互是比较麻烦的，可能我们第一想到的是使用广播接收器来在它们之间进行交互。如上文所说，在Activity-B中发一个广播，在Activity-A中注册一个广播接收器来接收该广播。但使用广播接收器稍显麻烦，如果你要将一个实体类当作数据在组件之间传递，那么该实体类还得实现序列化接口，这个成本实在有点高！如代码1所示。

class ActivityA extends Activity {  

        @Overrideprotected void onCreate(Bundle savedInstanceState) {  

            super.onCreate(savedInstanceState);             

              // ActivityA中注册广播接收器  

            registerReceiver(new BroadcastReceiver() {                  

                @Overridepublic void onReceive(Context context， Intent intent) {  

                    User person = intent.getParcelableExtra("user") ;  

                }  

            }， new IntentFilter("my_action")) ;  

        }  

        // ......   

    }      

    // ActivityB中发布广播  

    class ActivityB extends Activity {  

        @Overrideprotected void onCreate(Bundle savedInstanceState) {  

            super.onCreate(savedInstanceState);              

            // 发布广播  

            Intent intent  = new Intent("my_    action");  

            intent.putExtra("user"， new User("mr.simple")) ;  

            sendBroadcast(intent);  

        }  

        // ......   

    }     

    // 实体类需要实现序列化  

    class User implements Parcelable {  

        String name ;  

        public User(String aName) {  

            name = aName ;  

        }         

       // 代码省略  @Overridepublic void writeToParcel(Parcel dest， int flags) {  

            dest.writeString(name);  

        }  

    }  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    • 

  • 17
    • 

  • 18
    • 

  • 19
    • 

  • 20
    • 

  • 21
    • 

  • 22
    • 

  • 23
    • 

  • 24
    • 

  • 25
    • 

  • 26
    • 

  • 27
    • 

  • 28
    • 

  • 29
    • 

  • 30
    • 

  • 31
    • 

  • 32
    • 

  • 33
    • 

  • 34
    • 

  • 35
    • 

  • 36
    • 

  • 37
    • 

  • 38
    •

代码1

是不是有很麻烦的感觉？我们再来看一个示例，在开发过程中，我们经常要在子线程中做一些耗时操作，然后将结果更新到UI线程，除了AsyncTask之外，Thread加Handler是我们经常用的手段。如代码2所示。



class MyActivity extends Activity {          

        Handler mHandler = new Handler () {  

            public void handleMessage(android.os.Message msg) {  

                if ( msg.what == 1 ) {  

                    User user = (User)msg.obj ;  

                    // do sth  

                }  

            };  

        } ;         

        @Overrideprotected void onCreate(Bundle savedInstanceState) {  

            super.onCreate(savedInstanceState);  

            // code ......             new Thread(  

                new Runnable() {  

                    public void run() {  

                        // do sth  

                        User newUser = new User("simple") ;  

                        Message msg = mHandler.obtainMessage() ;  

                        msg.what = 1 ;  

                        msg.obj = newUser ;  

                        mHandler.sendMessage(msg) ;  

                    }  

            }).start();  

        }  

    }  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    • 

  • 17
    • 

  • 18
    • 

  • 19
    • 

  • 20
    • 

  • 21
    • 

  • 22
    • 

  • 23
    • 

  • 24
    • 

  • 25
    • 

  • 26
    • 

  • 27
    •

代码2

是不是依然相当麻烦？当然你也可以使用AsyncTask来简化操作，但AsyncTask的几个泛型参数让你的代码看起来并不那么简洁，因此GitHub上出现了TinyTask、SimpleTask这些开源库来简化AsyncTask的使用。而这些，使用AndroidEventBus都可以很好地解决！

下面就让我们来领悟一下AndroidEventBus的强大魅力吧。

初见AndroidEventBus

使用AndroidEventBus简单概括只有三个步骤：

  1. 将对象注册到AndroidEventBus中；
  2. 使用@Subcriber标注订阅函数（只能有一个参数）；
  3. 通过post函数发布事件。

对应的简单序列图如下 :

EventBusEventBus订阅对象订阅对象注册发布事件查找订阅对象订阅方法执行在具体的线程模型执行订阅方法

注册订阅对象

注册订阅对象，如代码3所示。

public class MainActivity extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {  

        super.onCreate(savedInstanceState);  

        setContentView(R.layout.activity_main);  

        // 将对象注册到事件总线中， ****** 注意要在onDestory中进行注销 ****  

        EventBus.getDefault().register(this);  

    }  

    @Overrideprotected void onDestroy() {  

        super.onDestroy();  

        // ****** 不要忘了进行注销 ****  

        EventBus.getDefault().unregister(this);  

    }      

    // 代码省略  

} 

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    •

代码3

在onCreate中注册之后，MainActivity就可以添加订阅函数来接收消息了。需要注意的是在onDestory中需要将MainActivity从事件总线中注销。通过AndroidEventBus你可以去除Activity、Fragment、Service等组件的回调，减少了耦合，简化了代码。

事件订阅函数

事件订阅需要使用@Subscriber注解进行标识，且订阅函数的参数必须为一个。事件总线凭借参数类型和@Subscriber注解的tag值来标识订阅函数的唯一性。当用户发布事件时，总线库会根据事件类型和tag来查找符合要求的订阅函数，并且将这些订阅函数执行在对应的线程中。我们先来看看代码4的订阅函数示例。

public class MainActivity extends Activity {// 代码省略   @Subcriber(tag = "csuicide")  

    private void csuicideMyself(String msg) {  

        // do sth  

        finish();  

    }  

    @Subcriber(mode = ThreadMode.MAIN)  

    private void toastMsgFromEvent(String msg) {  

        // do sth  

    }  

    @Subcriber(tag = "async"， mode = ThreadMode.ASYNC)  

    private void executeAsync(final String msg) {  

       // do sth  

    }  

    // 代码省略  

}   

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    • 

  • 17
    •

代码4

在代码4中，我们为MainActivity添加了以下三个订阅函数：

  • csuicideMyself：该订阅函数执行在主线程，接收事件的类型为String，tag为csuicide。当用户发布一个事件类型为String，且tag为csuicide的事件时将会触发该方法。
  • toastMsgFromEvent：该订阅函数也是执行在主线程，事件类型为String，且tag为默认。当用户发布一个事件类型为String，且tag为默认的事件时将会触发该方法。
  • executeAsync：该订阅函数也是执行在一个异步线程，事件类型为String，且tag为async。当用户发布一个事件类型为String，且tag为async的事件时将会触发该方法。 
    从上述的描述中我们可以知道，事件接收函数主要有两个约束：事件类型和tag（类似于Intent中的Action）。添加tag是因为在事件类型一样时，如果投递一个消息，那么单纯以事件类型（例如String）作为投递依据，那么多个参数为String的订阅函数将会被触发，这极大地降低了灵活性。

发布事件

// 参数 1 为事件类型,无 tag

EventBus.getDefault().post("这是一个执行在异步线程的事件");

// 参数 1 为事件类型,参数 2 为 tag,tag 的类型为 String,类似 Intent 的 Action

EventBus.getDefault().post("这是一个执行在异步线程的事件", "async");

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    •

发布事件时可以构造任意类型的事件，如果没有tag则该参数可以省略。发布事件后，AndroidEventBus会根据事件类型和tag到已注册的订阅对象中查找符合要求的订阅函数，例如投递的第二个事件类型为String、tag为async，那么在MainActivity中符合要求的订阅函数就是：

@Subcriber(tag = "async"， mode = ThreadMode.ASYNC)  

 private void executeAsync(final String msg) {  

   // do sth  

 }  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    •

AndroidEventBus的ThreadMode

在上述代码中有一段代码是这样的：

@Subcriber(mode = ThreadMode.MAIN)  

 private void toastMsgFromEvent(String msg) {        

 } 

    

  • 1
    • 

  • 2
    • 

  • 3
    •

这个mode可是大有来头，它指定这个事件接收函数执行在哪个线程中。具体有如下三个选项：

  • ThreadMode.MAIN，事件接收函数执行在UI线程；
  • ThreadMode.POST，事件在哪个线程发布，接收函数就执行在哪个线程；
  • ThreadMode.ASYNC，事件执行在一个独立的异步线程中。

图1中，事件接收函数就执行在异步线程。通过这几个线程模型，我们就可以定制接收函数的执行线程。这样我们就可以使用AndroidEventBus做很多事了。比如发布一个事件，在这个事件接收函数中进行耗时操作；或下载图片、进行HTTP请求、I/O操作等，以及替换Thread、AsyncTask等组件。不过，AndroidEventBus的功能远不止于此，下面我们就看看如何进行更高端的操作。

图1 接收函数执行在异步线程中

还可以怎么玩？

退出应用的另类实现

在Android应用开发中，有些情况下我们需要可以直接退出程序。但问题是，回退栈中含有其他的Activity存在，直接使用返回键并不能退出应用。此时我们常见的做法是再自定义一个Application子类，在子类中维护一个Activity的列表，然后在进入Activity时，将Activity添加到列表中，在Activity销毁之前将自己从Application子类的列表中移除。在需要退出应用时遍历Application子类的Activity列表，然后调用每个Activity的finish函数。那我们看看AndroidEventBus怎么实现这个功能。如代码5所示。

public class CsuicideActivity extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {  

        super.onCreate(savedInstanceState);  

        // 将对象注册到事件总线中， ****** 注意要在onDestory中进行注销 ****  

        EventBus.getDefault().register(this);  

    }  

    @Overrideprotected void onDestroy() {  

        super.onDestroy();       

        // ****** 不要忘了进行注销 ****  

        EventBus.getDefault().unregister(this);  

    }  

    @Subcriber(tag = "csuicide")  

    private void csuicideMyself(String msg) {  

        finish();  

    }  

}  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    • 

  • 17
    • 

  • 18
    •

代码5

代码5中，我们定义一个CsuicideActivity在onCreate中注册该Activity对象，在onDestroy中注销，还添加了一个csuicideMyself的订阅函数。所有的Activity类可以继承自CsuicideActivity。当需要退出应用时，直接发布一个类型为String、tag为csuicide的事件即可。这样所有的Activity就会触发csuicideMyself，而该函数中又调用了finish方法，因此所有的Activity都将退出，通过这种方式就完成了应用退出。

自定义事件处理器 ( EventHandler )

AndroidEventBus在设计之初就考虑到了可扩展性，主要可扩展的地方就是订阅函数的搜索策略，具体可以调用EventBus.getDefualt().setMatchPolicy(MatchPolicy policy)来实现策略替换。另一个比较重要的扩展就是事件处理器EventHandler，用户可以通过setter函数来设置三个事件处理器。如代码6所示。

 /** 

   * 设置执行在UI线程的事件处理器 

   * @param handler   UI线程事件处理器 

   */public void setUIThreadEventHandler(EventHandler handler) {  

      mDispatcher.mUIThreadEventHandler = handler;  

  }  

  /** 

   * 设置执行在post线程的事件处理器 

   * @param handler 事件在哪个线程投递，事件就执行在哪个线程的事件处理器 

   */public void setPostThreadHandler(EventHandler handler) {  

mDispatcher.mPostThreadHandler = handler;  

  }  

  /** 

   * 设置执行在异步线程的事件处理器 

   * @param handler 异步线程事件处理器 

   */public void setAsyncEventHandler(EventHandler handler) {  

      mDispatcher.mAsyncEventHandler = handler;  

  } 

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    • 

  • 16
    • 

  • 17
    • 

  • 18
    • 

  • 19
    • 

  • 20
    • 

  • 21
    •

代码6

EventHandler的接口定义如代码7所示，只需实现handleEvent即可，然后将该实现注入到EventBus即可。

/** 

 * 事件处理接口，处理事件的抽象 

 */public interface EventHandler {/** 

     * 处理事件 

     * @param subscription 订阅对象 

     * @param event 待处理的事件 

     */void handleEvent(Subscription subscription， Object event);  

}  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    •

代码7

默认有DefaultEventHandler、UIThreadEventHandler、AsyncEventHandler三个实现：

  • DefaultEventHandler：事件在哪个线程发布，就将事件接收函数执行在哪个线程；
  • UIThreadEventHandler：将事件接收函数执行在UI线程；
  • AsyncEventHandler：将事件接收函数执行在异步线程。

下面我们以自定义异步事件处理器，也就是AsyncEventHandler，通过实现EventHandler接口，将事件处理函数执行在一个线程池中，从而实现图片下载的功能。如代码8所示。

public class ThreadPoolHandler implements EventHandler {  

    ExecutorService mExecutorService = Executors.newFixedThreadPool(3);  

    EventHandler mHandler = new DefaultEventHandler();  

    @Overridepublic void handleEvent(final Subscription subscription， final Object event) {  

        mExecutorService.submit(new Runnable() {  

            @Overridepublic void run() {  

                mHandler.handleEvent(subscription， event);  

            }  

        });  

    }  

}  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    •

代码8

然后通过如下代码将ThreadPoolEventHandler注入到AndroidEventBus中：

// 自定义的异步事件处理器，使用线程池  

 EventBus.getDefault().setAsyncEventHandler(new ThreadPoolHandler());  

    

  • 1
    • 

  • 2
    •

再在订阅对象中添加代码9所示的订阅方法 ：

@Subcriber(tag = "download"， mode = ThreadMode.ASYNC)  

private void downloadImage(final String imageUrl) {  

    HttpURLConnection urlConnection = null;  

    try {  

        final URL url = new URL(imageUrl);  

        urlConnection = (HttpURLConnection) url.openConnection();  

        final Bitmap bmp = BitmapFactory.decodeStream(urlConnection.getInputStream());           

        // 将Bitmap投递给ImageView之类的工作  

    } catch (IOException e) {  

    } finally {  

        if (urlConnection != null) {  

            urlConnection.disconnect();  

        }  

    }  

}  

    

  • 1
    • 

  • 2
    • 

  • 3
    • 

  • 4
    • 

  • 5
    • 

  • 6
    • 

  • 7
    • 

  • 8
    • 

  • 9
    • 

  • 10
    • 

  • 11
    • 

  • 12
    • 

  • 13
    • 

  • 14
    • 

  • 15
    •

代码9

最后，当需要下载图片时，通过post发布一个参数为String类型、tag为download的事件即可执行downloadImage函数，这个函数将执行在线程池中，我们的简易ImageLoader就这么实现了。



 

 
图2 图片下载中 图3 图片下载完成

当然，由于AndroidEventBus的高度定制化，我们还可以通过AndroidEventBus来实现各种各样的功能，它到底还能怎么玩，我就不做过多的演示了，开发者可以充分发挥自己的聪明才智和想象力。

来自为知笔记(Wiz)

时间： 2024-10-23 20:07:51

Android事件总线的相关文章

android事件总线(eventbus)设计与实现

1. 功能介绍 AndroidEventBus是一个Android平台的事件总线库, 它简化了Activity.Fragment.Service等组件或者对象之间的交互,很大程度上降低了它们之间的耦合,使得我们的代码更加简洁,耦合性更低,提升我们的代码质量. AndroidEventBus吸收了greenrobot的EventBus以及square的otto的优点,并在此基础上做出了相应的改进,使得事件总线框架更适合用户的使用习惯,也使得事件的投递更加的精准.灵活. 与EventBus.otto

Android 事件总线OTTO使用说明和源码解析

一.Otto简单介绍 OTTO是Square推出的库,地址:https://github.com/square/otto 先来看看otto的官方介绍 An enhanced Guava-based event bus with emphasis on Android support.Otto is an event bus designed to decouple different parts of your application while still allowing them to c

Android事件总线（二）EventBus3.0源码解析

相关文章 Android事件总线(一)EventBus3.0用法全解析 前言 上一篇我们讲到了EventBus3.0的用法,这一篇我们来讲一下EventBus3.0的源码以及它的利与弊. 1.构造函数 当我们要调用EventBus的功能时,比如注册或者发送事件,总会调用EventBus.getDefault()来获取EventBus实例: public static EventBus getDefault() { if (defaultInstance == null) { synchroniz

Android退出程序（三）——Android事件总线

概述 当我们跟随时间的脚步向前挪动的时候,总能发现原来以前的自己做了一些愚蠢的事情.但,不见得以前就是不好的事情.我在以前的博客中写过两种关于Android中如何退出应用程序的方法.近日,我又发现了一个看似高大上的方法,因为作为程序员的你,使用起来会更加方便.它就像是你得心应手的工具,在需要的时候让你有一种,还好有它的感觉.下面我就使用Android事件总线来对Android退出程序作一个说明. AndroidEventBus简介 AndroidEventBus是一个Android平台的事件总线

Android事件总线分发库EventBus3.0的简单讲解与实践

Android事件总线分发库EventBus的简单讲解与实践 导语,EventBus大家应该不陌生,EventBus是一款针对Android优化的发布/订阅事件总线.主要功能是替代Intent,Handler,BroadCast在Fragment,Activity,Service,线程之间传递消息.优点是开销小,代码更优雅.以及将发送者和接收者解耦.反正能帮助我们快速开发,这个确实是个好东西,其实鸿洋大神已经对源码作了一个较全面的剖析了 Android EventBus源码解析 带你深入理解Ev

android事件总线(eventbus)开源库发布

 AndroidEventBus 如果你不知道事件总线是什么,那么没有关系,下面我们先来看这么一个场景: 你是否在开发的过程中遇到过想在Activity-B中回调Activity-A中的某个函数,但Activity又不能手动创建对象来设置一个Listener什么的? 你是否想在某个Service中想更新Activity或者Fragment中的界面? 等等之类的组件之间的交互问题-- 一经思考,你会发现Android中的Activity, Fragment, Service之间的交互是比较麻烦的,

Android事件总线还能怎么玩？

作者简介:何红辉,Android工程师,现任职于友盟. 顾名思义,AndroidEventBus是一个Android平台的事件总线框架,它简化了Activity.Fragment.Service等组件之间的交互,很大程度上降低了它们之间的耦合,使我们的代码更加简洁,耦合性更低,提升了我们的代码质量.但它能做的却不仅限于这些.经过定制,它能完成很多有意思的功能,那么究竟该怎么做呢?就让我们一起往下看吧. 不堪回首的痛 首先,让我们先来看看这么一个场景:你是否在开发的过程中遇到过从Activity-

【第一篇】学习 android 事件总线androidEventbus之sticky事件的传递

最近再看eventbus相关代码,首先从使用开始,后期再从源码角度分析eventbus.使用Demo后期公布到github上去. 使用的框架地址:https://github.com/bboyfeiyu/AndroidEventBus Sticky 事件 使用例子: 1,首先每个Activity或者fragement都要进行eventBus的注册和反注册. 发送sticky事件的activity: 1 package com.example.mysimpleeventbus; 2 import

Android事件总线 浅谈 EventBus

EventBus官方文档是这么写的:EventBus is a publish/subscribe event bus optimized for Android. 也就是说EventBus是Android下高效的发布/订阅事件总线机制. EventBus可以代替传统的Intent,Handler,Broadcast或接口函数在Fragment,Activity,Service,线程之间传递数据,执行方法. 我们先来看看官方文档对EventBus的介绍: simplifies the commu