EventBus使用与源码分析

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量89 收藏
点赞数
分类专栏： 开源框架 文章标签： java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangadping/article/details/117768065
版权

  1. EventBus简介

    ​ EventBus基于观察者设计模式，通过事件的发送和订阅，方便模块间的通讯与解耦。官方的介绍图如下：
    在这里插入图片描述

​ 最新版V3.2.0-EventBus模块如下

模块描述
EventBusEventBus源码
EventBusAnnotationProcessorEventBus注解处理器源码，V3.0引入，提升效率
EventBusPerformanceEventBus与Otto速度测试
EventBusTest/EventBusTestJava/EventBusTestSubscriberInJarEventBus测试工程

2.使用示例代码

// gradle引入EventBus依赖
implementation 'org.greenrobot:eventbus:3.2.0'

public class MainActivity extends AppCompatActivity {

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


    @Override
    protected void onStart() {
        super.onStart();
        // 2.Publisher发送事件
        EventBus.getDefault().post("Hello World");
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 1-3.反注册Subscribers
        EventBus.getDefault().unregister(this);
    }

    // 1-2.定义Subscribers收到事件时的回调处理
    @Subscribe
    public void hello(String words) {
        Log.d("MainActivity", "receive hello event: " + words);
    }
}

3.源码分析

  1. EventBus.getDefault()，通过单例提供了EventBus的入口

     public static EventBus getDefault() {
        EventBus instance = defaultInstance;
        if (instance == null) {
            synchronized (EventBus.class) {
                instance = EventBus.defaultInstance;
                if (instance == null) {
                    instance = EventBus.defaultInstance = new EventBus();
                }
            }
        }
        return instance;
}

  2. 注册事件订阅者

     public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
}

    • subscribe()将订阅者与其事件处理方法联系在一起，在后续发送者发送事件时调用

       private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
      ......
      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);
      }
      subscribedEvents.add(eventType);
      ......
    }

    • 上面register()方法中，创建了SubscriberMethodFinder（订阅者方法搜寻器）对象，该对象是在EventBus构造函数中生成；findSubscriberMethods()方法作用就是找到所有@Subscribe注解的方法

      EventBus(EventBusBuilder builder) {
    ...
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
    builder.strictMethodVerification, builder.ignoreGeneratedIndex);
    ...
}

    • findSubscriberMethods：找到订阅者方法并放入缓存中

      List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    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;
    }
}

    ​ 通过分析ignoreGeneratedIndex默认false， 因此执行subscriberMethods = findUsingInfo(subscriberClass)，具体代码如下：

    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        // 准备FindState
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 获取订阅者信息
            findState.subscriberInfo = getSubscriberInfo(findState);
            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 {
                // 默认subscriberInfo=null，执行这里的的代码
                findUsingReflectionInSingleClass(findState);
            }
            // 向订阅者父类查找
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(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
            try {
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
                String msg = "Could not inspect methods of " + findState.clazz.getName();
                if (ignoreGeneratedIndex) {
                    msg += ". Please consider using EventBus annotation processor to avoid reflection.";
                } else {
                    msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
                }
                throw new EventBusException(msg, error);
            }
            findState.skipSuperClasses = true;
        }
        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");
            }
        }
    }

  3. 发送事件、事件的处理

    ​ post()方法先将事件推到事件队列，之后遍历出队，postSingleEvent()完成单个事件的发送。

      public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        eventQueue.add(event);

        if (!postingState.isPosting) {
            postingState.isMainThread = isMainThread();
            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;
            }
        }
    }

    ​ eventInheritance默认true，lookupAllEventTypes()方法循环所有事件，postSingleEventForEventType()方法发送事件到每个订阅者

    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        // eventInheritance = true,执行下面的代码
        if (eventInheritance) {
            // 向上获取到父类的所有事件
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                // 发送单个事件
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }
        if (!subscriptionFound) {
            if (logNoSubscriberMessages) {
                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

    ​ postSingleEventForEventType()后续代码如下：

    // 遍历发送单个事件到订阅者 
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted;
                try {   
                    postToSubscription(subscription, event, postingState.isMainThread);
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }
// 进行线程判断
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED:
                if (mainThreadPoster != null) {
                    mainThreadPoster.enqueue(subscription, event);
                } else {
                    // temporary: technically not correct as poster not decoupled from subscriber
                    invokeSubscriber(subscription, event);
                }
                break;
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC:
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

// 通过反射调用订阅者的方法，实现订阅者对事件的处理
void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

  4. 小结

    从上面的源码分析中，可以看出订阅者(Subscriber)注册事件订阅(register)后，通过订阅(subscribe)将事件处理方法联系起来，发送者(Publisher)发送事件后(post)，订阅者在事件处理方法完成接收事件的处理。

4.总结

​ EventBus从总体上看还是比较简单，主要涉及1.自定义注解、APT 2.观察者设计模式两个方面技术栈。

dongpingwang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Caused by: de.greenrobot.event.EventBusException: Subscriber class has no public methods called on
a865074284的博客
03-27 3848
使用eventbus时，在debug版本中，是没有问题的，但是release打包后，就出现了这个问题 257行是EventBus.getDefault().register(this); 解决办法：在打包的时候，混淆出问题了 需要加上-keepclassmembers class ** { public void onEvent*(**); }这个混淆
org.greenrobot.eventbus.EventBusException: Subscriber class already registered to event class
热门推荐
yfbdxz的博客
05-14 1万+
org.greenrobot.eventbus.EventBusException: Subscriber class com.hj.eventbus.Activity2 already registered to event class com.hj.eventbus.BtnEvent直译： EventBus异常：Activity2已经注册过EventBus。 相关代码： class Acti
Eventbus错误：org.greenrobot.eventbus.EventBusException: Subscriber class
weixin_40420578的博客
09-02 4946
org.greenrobot.eventbus.EventBusException: Subscriber class com.example.module_login.ui.activity.LoginActivity already registered to event class com.example.module_common.eventbus.MessageEvent Androi...
eventbus报错:org.greenrobot.eventbus.EventBusException: Subscriber class ... its super classes have no
蓝不蓝编程
05-31 9266
报错信息 2019-05-31 09:15:34.049 2580-2580/com.cxyzy.note E/AndroidRuntime: FATAL EXCEPTION: main Process: com.cxyzy.note, PID: 2580 java.lang.RuntimeException: Unable to start activity ComponentI...
eventbus使用与源码分析
一骑绝尘，笑傲江湖
07-11 172
  1. 依赖 compile 'org.greenrobot:eventbus:3.0.0'   2.EventBus的三要素 : (1) Event：事件，可以是任意类型的对象。 (2) Subscriber：事件订阅者， 在EventBus3.0之前消息处理的方法只能限定于onEvent、onEventMainThread、onEventBackgroundThread和onE...
EventBus的使用实例源码
08-10
通过分析代码，你可以看到如何将上述知识点应用到实践中，从而更好地理解和掌握 EventBus 的使用。 总之，EventBus 提供了一种优雅的解决方案，用于在 Android 应用的不同组件之间传递消息，特别是对于实时更新界面...
EventBus学习源码
12-18
本文将深入探讨 EventBus 的源码，帮助你理解其工作原理。 首先，我们要了解 EventBus 的核心概念：发布（Posting）、订阅（Subscribing）和粘性事件（Sticky Events）。发布是通过调用 `EventBus.getDefault()....
eventBus 3.0 带有注释的源码
05-31
源码分析主要涉及以下几个核心知识点： 1. **发布与订阅（Posting and Subscribing）**： - 发布事件（Posting Events）：EventBus 提供了 `post()` 方法来发布自定义事件对象。这些事件可以是任何 Java 对象，但...
EventBus3.0源码解析.md
08-12
基于Eventbus3的源码分析 从初始化到注册、post、接收、注销的一系列流程分析 文件为markdown
EventBus源码及demo
09-07
在 "EventBus源码及demo" 中，我们可以深入理解 EventBus 的工作原理以及如何在实际应用中使用。 **1. EventBus 的基本概念** EventBus 提供了一种基于发布/订阅的事件传递机制。发布者（Publisher）发布事件，订阅...
解决Caused by: org.greenrobot.eventbus.EventBusException: Subscriber class ... and its super
weixin_43779101的博客
07-02 8805
Caused by: org.greenrobot.eventbus.EventBusException: Subscriber class … and its super classes have no public methods with the @Sub 百度找了很多答案，但是没有一个跟我犯同样错误的，都是因为public的原因 看代码，我有一个@Subscribe注解并且是public的...
EventBus3.1.1 解决 Caused by: org.greenrobot.eventbus.EventBusException: Subscriber class ... and its ...
weixin_33998125的博客
04-22 2473
小菜今天自己写测试 Demo 时，需要用到 EventBus，目前集成 3.1.1 版本，集成的方式很简单，在某个 Fragment 实践应用中，却一直报入下错： Caused by: org.greenrobot.eventbus.EventBusException: Subscriber cl...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 600
1.导入hutool的maven依赖。2.复制一下代码执行。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 559
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 515
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 478
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 359
1.导入hutool的maven依赖。2.直接复制一下代码运行。
eventbus 使用
08-01
使用Eventbus，开发者只需要定义事件类和订阅者类，然后在需要通信的地方发布事件即可。Eventbus会自动将事件分发给所有订阅者，并在主线程或者后台线程中执行订阅者的回调方法。这样，开发者就可以轻松地实现组件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值