EventBus的使用技巧和解析

最新推荐文章于 2023-12-07 20:32:13 发布
最新推荐文章于 2023-12-07 20:32:13 发布
阅读量2.5k 收藏
点赞数
分类专栏： android-开发 安卓基础 文章标签： android 框架 EventBus 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_34928905/article/details/78965307
版权

EventBus的使用技巧和解析

一、EventBus简介

EventBus由greenrobot组织贡献(该组织还贡献了greenDAO)，一个Android事件发布/订阅轻量级框架。
它是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。

  • EventBus原理框图

这里写图片描述

  • 下面展示使用EventBus写的一个Demo

这里写图片描述

二、下载地址

EventBus在github的地址

三、使用步骤

1）添加jar包到libs文件夹下或者添加gradle依赖
2）注册：EventBus.getDefault().register(this); 

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

    EventBus.getDefault().register(this);
}

3）解注册：EventBus.getDefault().unregister(this);

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

4）构造发布消息类

public class MessageEvent {
    public String msg;

    public MessageEvent(String msg) {
        this.msg = msg;
    }
}

5）发布消息

EventBus.getDefault().post(new MessageEvent("我是刚过来的-.-"));

6）接收消息

@Subscribe(threadMode = ThreadMode.MAIN)
    public void messageEventBus(MessageEvent event){
        tv_result.setText(event.msg);
    }

有四种模式的threadMode

  • ThreadMode.MAIN 表示这个方法在主线程中执行
  • ThreadMode.BACKGROUND 表示该方法在后台执行，不能并发处理
  • ThreadMode.ASYNC 也表示在后台执行，可以异步并发处理
  • ThreadMode.POSTING 表示该方法和消息发送方在同一个线程中执行
四、粘性事件

之前说的使用方法, 都是需要先注册(register), 再post,才能接受到事件;
如果你使用postSticky发送事件, 那么可以不需要先注册, 也能接受到事件.
1）构造发送信息类

public class StickyEvent {
    public String msg;

    public StickyEvent(String msg) {
        this.msg = msg;
    }
}

2）发布消息

EventBus.getDefault().postSticky(new StickyEvent("我是粘性消息~"));

3）接收消息

    //注意,和之前的方法一样,只是多了一个 sticky = true 的属性.
    @Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
    public void onEvent(StickyEvent event){
        tv_c_result.setText(event.msg);
    }

4）注册

EventBus.getDefault().register(CActivity.this);

5）解注册

EventBus.getDefault().removeAllStickyEvents();
EventBus.getDefault().unregister(CActivity.class);
五、源码解析

1）注册（订阅）源码分析

EventBus.getDefault().register(CActivity.this);

跟进getDefault()方法

    public static EventBus getDefault() {
        // 单例设计
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }
  // 可以看出来，EventBus是单例模式存在的，一个项目中只能有一个EventBus这样有利于管理订阅者和订阅方法，这会在下面的介绍中体现出来。  


 public EventBus() {
        this(DEFAULT_BUILDER);
  }

可以发现：EventBus采用双重校验锁设计为一个单例模式，奇怪的在于虽然设计为单例模式，但是构造方法确实public类型。EventBus默认支持一条事件总线，通常是通过getDefault()方法获取EventBus实例，但也能通过直接new EventBus这种最简单的方式获取多条事件总线，彼此之间完全分开。
接着，跟进register(Object subscriber)方法

// 1 注册
public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();

        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
}

订阅方法实体类

// 1.1 订阅方法的实体类
public class SubscriberMethod {
    final Method method;                    // 方法
    final ThreadMode threadMode;    // 执行线程
    final Class<?> eventType;           // 接收事件类型
    final int priority;                         // 优先级
    final boolean sticky;                   // 粘性事件
    /** Used for efficient comparison */
    String methodString;

    public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
        this.method = method;
        this.threadMode = threadMode;
        this.eventType = eventType;
        this.priority = priority;
        this.sticky = sticky;
    }

    //。。。。
}

从订阅类中获取所有的订阅方法信息

// 1.2 从订阅类中获取所有的订阅方法信息；
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {

        // 首先从缓存中读取
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        // 默认false
        if (ignoreGeneratedIndex) {
            // 利用反射来获取订阅类中的订阅方法信息
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 从注解器生成的类中获得订阅类的订阅方法信息
            subscriberMethods = findUsingInfo(subscriberClass);
        }

        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            // 保存进缓存
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

先看看通过反射来获取订阅方法信息的方法findUsingReflection()

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {

        FindState findState = prepareFindState();

        findState.initForSubscriber(subscriberClass);

        while (findState.clazz != null) {
            // 取订阅类的方法信息
            findUsingReflectionInSingleClass(findState);

            findState.moveToSuperclass();
        }

        // 释放findState集合，并返回订阅类的方法
        return getMethodsAndRelease(findState);
    }

FindState其实就是一个里面保存了订阅者和订阅方法信息的一个实体类，包括订阅类中所有订阅的事件类型和所有的订阅方法等。

我们看到会首先创建一个FindState对象并执行findUsingReflectionInSingleClass(findState);来获取订阅类的方法信息

跟进findUsingReflectionInSingleClass(findState)方法

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {

            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            // 通过反射获取到订阅类中的所有方法
            methods = findState.clazz.getMethods();

            findState.skipSuperClasses = true;
        }

        // 遍历所有方法，忽略private类型的，最后如果是公有，并且不是 
        // java编译器 生成的方法名，那么就是我们要的了。
        for (Method method : methods) {
            int modifiers = method.getModifiers();

            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();

                if (parameterTypes.length == 1) {

                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);

                    // 保证只有一个事件参数
                    if (subscribeAnnotation != null) {

                        Class<?> eventType = parameterTypes[0];

                        // 校验是否添加该方法
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();

                            // 添加方法
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();

                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();

                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }


可以看到，首先会得到订阅类的class对象并通过反射获取订阅类中的所有方法信息，然后通过筛选获取到订阅方法集合。

程序执行到此我们就获取到了订阅类中的所有的订阅方法信息

退回去再看看通过注解获取订阅方法信息findUsingInfo()

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        // 从FIND_STATE_POOL数组中查找FindState，命中返回，否则直接new
        FindState findState = prepareFindState();

        // 初始化FindState
        findState.initForSubscriber(subscriberClass);

        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);

            // findState.subscriberInfo默认null
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

接着走注册订阅方法subscribe()：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        // 获取订阅方法的事件类型
        Class<?> eventType = subscriberMethod.eventType;

        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        // 根据订阅的事件类型获取所有的订阅者
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);

        // 将订阅者添加到subscriptionsByEventType集合中
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        // 根据优先级，将订阅者插入到指定的位置
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        // 获取订阅者所有订阅的事件类型
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }

        // 将该事件类型添加到typesBySubscriber中
        subscribedEvents.add(eventType);

        // 如果接收sticky事件,立即分发sticky事件
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                // Existing sticky events of all subclasses of eventType have to be considered.
                // Note: Iterating over all events may be inefficient with lots of sticky events,
                // thus data structure should be changed to allow a more efficient lookup
                // (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry<Class<?>, Object> entry : entries) {
                    Class<?> candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

总结一下，注册EventBus主要干了几件事

  • 首先获取订阅方法的参数类型即订阅事件类型
  • 根据订阅事件类型获取该事件类型的所有订阅者
  • 将该订阅者添加到该事件类型的订阅者集合中即：subscriptionsByEventType
  • 获取订阅者所有的订阅事件类型
  • 将该事件类型添加到该订阅者的订阅事件类型集中即:typesBySubscriber

这里写图片描述
附上流程图：
这里写图片描述

2）发布消息源码解析

EventBus.getDefault().post("发送普通数据");

getDefault方法跟上面注册源码中的getDefault方法是一样的，主要看post方法

public void post(Object event) {

        // 获取当前线程的postingState
        PostingThreadState postingState = currentPostingThreadState.get();

        // 取得当前线程的事件队列
        List<Object> eventQueue = postingState.eventQueue;

        // 将该事件添加到当前的事件队列中等待分发
        eventQueue.add(event);

        if (!postingState.isPosting) {
            // 判断是否是在主线程post
            postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
            postingState.isPosting = true;

            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                while (!eventQueue.isEmpty()) {
                    // 分发事件
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

这里写图片描述

3）取消注册源码分析

EventBus.getDefault().unregister(this);

跟进unregister()方法：

    public synchronized void unregister(Object subscriber) {
        //获取订阅者的所有订阅的事件类型
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);

        if (subscribedTypes != null) {

            for (Class<?> eventType : subscribedTypes) {
                //从事件类型的订阅者集合中移除订阅者
                unsubscribeByEventType(subscriber, eventType);
            }

            typesBySubscriber.remove(subscriber);
        } else {
            Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

这里写图片描述

六、总结

（1）EventBus总线接收消息四大线程
（2）粘性事件的特点
（3）注册源码分析

  • 通过反射或注解获取所有的订阅方法
  • 将当前订阅者添加到Eventbus总的事件订阅者的集合中
  • 将当前订阅者所有订阅的事件类型添加到typeBySubscriber中

（4）发送源码分析

  • 得到要发送的事件类型
  • 根据事件类型获取所有订阅者，并循环向每个订阅者发送

（5）解注册源码分析

  • 通过typeBySubscriber获取当前订阅者所有的事件类型
  • 循环遍历每一个事件类型，并删除当前订阅者的订阅的方法
七、参考网站

EventBus3.0源码解析
Android EventBus3.0使用及源码解析
相关Demo可以去我github上的项目看看源码:
传送门

ok406lhq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android | EventBus使用详解
cyc的专栏
12-30 5万+
EventBus是一种用于Android的发布/订阅事件总线。它有很多优点：简化应用组件间的通信；解耦事件的发送者和接收者；避免复杂和容易出错的依赖和生命周期的问题；很快，专门为高性能优化过等等。
Vert.x(vertx) 事件总线（EventBus）与 远程服务调用
热门推荐
happyfly的博客
02-11 1万+
Event Bus（事件总线） 是Vert.x的神经系统，负责应用系统消息的传递。Vert.x各模块（Verticle）之间的相互调用就是通过Event Bus实现的，因此各Verticle之间是高度解耦的。 Event Bus提供发布订阅功能和点对点的消息服务，类似于消息队列，每条消息在Event Bus上都有一个地址（address），发布者向这个地址发送消息，接收者从这个地址接收消息。 ...
EventBus 的使用
gdvfs12的博客
03-21 5779
EventBus 的使用一、前言二、关于EventBus的概述1、三个角色2.四种线程模型三、EventBus的使用1、导入依赖2、自定义事件封装类3、注册事件4、发布事件5、处理事件四、 普通事件与粘性事件 一、前言 在进行Android开发时，当涉及大量组件之间的通信，使用Intent、Handler、Broadcast进行模块间通信、模块与后台线程进行通信时，代码量大，而且高度耦合。EventBus简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带
Vue事件总线（EventBus）使用指南：详细解析与实战应用
在这里，我分享我的技术心得、项目经验、实用的技术教程、深入的技术分析以及前端开发的最新动态，希望能帮助到更多的人。
05-31 6415
vue组件非常常见的有父子组件通信，兄弟组件通信。而父子组件通信就很简单，父组件会通过 props 向下传数据给子组件，当子组件有事情要告诉父组件时会通过 $emit 事件告诉父组件。今天就来说说如果两个页面没有任何引入和被引入关系，该如何通信了？如果咱们的应用程序不需要类似Vuex这样的库来处理组件之间的数据通信，就可以考虑Vue中的 事件总线 ，即EventBus来通信。EventBus 又称为事件总线。
java eventbus 原理_Guava EventBus 原理
weixin_32461163的博客
03-04 272
创建一个Map key可以重复的：//参数就是一个普通的Listenerprivate Multimap, Subscriber> findAllSubscribers(Object listener) {//创建一个key 可以重复的Map key ： class 信息 Subscriber Value 是订阅者Multimap, Subscriber> methodsInList...
EventBus的使用以及注意事项
最新发布
m0_73986294的博客
12-07 220
Android系统中的事件通信是 handler (消息机制) 和 BroadCastReceiver (广播机制)， 通过它们可以实现组件之间的事件通讯。缺点在于，代码量多、组件之易产生藕合引用。这时候EventBus就展示出了他的优点EventBus 是一种在软件开发中使用的发布/订阅（Pub/Sub）事件通信机制假设你是一个读者，你对多个报纸感兴趣，但你并不想每天亲自去买每一份报纸。这时，你可以选择订阅报纸的服务。
EventBus的介绍和使用
01-03
EventBus的介绍和使用EventBus的介绍作用引入成员综合小案例:1,Activity中的布局:2 Activity中的代码:3 fragment中的代码:4 .fragment中的布局只有一个textView 不放代码了.线程模型线程模型的用处:官方网址: ...
android的数据传递EventBus使用解析
02-24
1.下载EventBus 2.如何使用EventBus 3.主界面搭建 4.EventBus框架原理流程图
Flutter中EventBus的使用
01-07
参考文档：电梯直达 EventBusUtils //订阅者回调签名 typedef void EventCallback(arg);... static EventBus _singleton = new EventBus._internal(); /// 工厂构造函数 factory EventBus() => _singleton; /// 保
EventBus使用例子
06-09
EventBus使用
详解vue 组件之间使用eventbus传值
01-21
对于前端的我们而言，并非是只有写界面才是最大的问题，很多的情况下，我们需要关注的是数据，比如js页面的数据传递等等，学习vue我们也是需要知道怎么去使用数据 当然，使用存储也是可以得，但是并非一定要缓存，...
EventBus使用详解教程，带你学习eventbus。详解Demo
09-06
注意事项遇到问题请看：http://blog.csdn.net/qq_21376985/article/details/52438143
Eventbus的详细使用
11-15
主要介绍了eventbus的使用方法，替代Handle,来实现数据的接收与发送。
EventBus(事件总线)的使用和源码的简单解析
Tai_Monster的博客
04-29 5815
事件总线（EventBus）是一种广泛用于软件架构中的设计模式，用于实现解耦和松散耦合的通信机制。它可以帮助组织和管理应用程序中不同组件之间的通信，以提高应用程序的可维护性、可扩展性和灵活性。 在事件总线模式中，不同的组件通过订阅和发布事件来进行通信。发布者发布一个事件，订阅者可以订阅该事件并在事件发生时执行相关的操作。事件总线充当了中介者的角色，它负责管理所有的事件和订阅者，并确保事件正确地传递到所有订阅者。 事件总线模式可以在很多场景中使用，例如 Android 应用程序中的通信、分布式系统中的消息
EventBus的简单使用
紫微星的博客
03-25 4882
不愧是我
EventBus源码解析
zhq217217的博客
03-12 2540
今天开始拆分EventBus源码，废话少说，五步骤，如何使用，源码解析，学到了什么，有什么不足之处 第一部分：如何使用 //第二步：注册 接收类 EventBus.getDefault().register(this); //第三步，发送事件 发送事件 事件参数 EventBus.getDefault().post(new Object()); //第四步，注销注册 EventBus.g
EventBus的四种监听接收方式
Jermmy1207的博客
10-28 1214
1. onEvent() 使用onEvent来接收事件，那么接收事件和post事件在同一个线程中执行。 2. onEventMainThread() 使用onEventMainThread来接收事件，那么不论post事件在哪个线程运行，接收事件永远在UI线程执行。 3. onEventBackgroundThread() 使用onEventBackgroundThrea...
EventBus的使用
Sean豆子
11-06 232
今日学习了EventBus的使用，
教你在任何地方使用 EventBus 发送接收消息
Mr_Liangxiaobai的博客
06-30 444
EventBus，教你在任何地方使用 EventBus 发送接收消息。
eventbus 使用
08-01
使用Eventbus，开发者只需要定义事件类和订阅者类，然后在需要通信的地方发布事件即可。Eventbus会自动将事件分发给所有订阅者，并在主线程或者后台线程中执行订阅者的回调方法。这样，开发者就可以轻松地实现组件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值