EventBus 原理简单记录

最新推荐文章于 2023-01-18 10:57:47 发布
最新推荐文章于 2023-01-18 10:57:47 发布
阅读量368 收藏
点赞数
分类专栏： 开源框架 文章标签： EventBus 事件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iluojie/article/details/80723190
版权

这里写图片描述

1、获取 EventBus 对象

EventBus.getDefault()

//单例双重检查方式
public static EventBus getDefault() {  
        if (defaultInstance == null) {  
            synchronized (EventBus.class) {  
                if (defaultInstance == null) {  
                    defaultInstance = new EventBus();  
                }  
            }  
        }  
        return defaultInstance;  
} 

public EventBus() {  
       this(DEFAULT_BUILDER);  
}  

// 建造者模式构造 EventBus
EventBus(EventBusBuilder builder) {  
    subscriptionsByEventType = new HashMap<>();  
    typesBySubscriber = new HashMap<>();  
    stickyEvents = new ConcurrentHashMap<>();  
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);  
    backgroundPoster = new BackgroundPoster(this);  
    asyncPoster = new AsyncPoster(this);  
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;  
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,  
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);  
    logSubscriberExceptions = builder.logSubscriberExceptions;  
    logNoSubscriberMessages = builder.logNoSubscriberMessages;  
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;  
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;  
    throwSubscriberException = builder.throwSubscriberException;  
    eventInheritance = builder.eventInheritance;  
    executorService = builder.executorService;  
}

2、注册订阅者

EventBus.getDefault().register(this)

public void register(Object subscriber) {  
       Class<?> subscriberClass = subscriber.getClass(); 
       //根据订阅者类名来查找订阅者的所有订阅方法 
       List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);  
       synchronized (this) {  
           // 把订阅者和订阅方法注册给事件发送者
           for (SubscriberMethod subscriberMethod : subscriberMethods) {  
               subscribe(subscriber, subscriberMethod);  
           }  
       }  
}

通过 subscriberMethodFinder 根据订阅者类名来查找订阅者的所有订阅方法，然后再把这些方法注册给事件发送者。

SubscriberMethod 类定义如下：

public class SubscriberMethod {  
    final Method method;  
    final ThreadMode threadMode;  
    final Class<?> eventType;  
    final int priority;  
    final boolean sticky;  
    /** Used for efficient comparison */  
    String methodString; 
    //.... 
}

2.1 如何获取订阅者的所有订阅方法信息

    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;  
           }  
}

2.2 for循环遍历 订阅每个方法

for (SubscriberMethod subscriberMethod : subscriberMethods) {  
      //订阅
      subscribe(subscriber, subscriberMethod);  
}

订阅方法实现算法
两个 map 来实现存储订阅的信息
key —————- value （list）
事件类型 ——— 订阅信息列表
订阅者 ———— 事件类型列表

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {  
        //获取订阅方法的的订阅事件类型
        Class<?> eventType = subscriberMethod.eventType;  
        //new 一个订阅信息（一个订阅者和它的一个订阅方法）
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);  
        //获取该事件类型的所有订阅信息集合
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);  
        if (subscriptions == null) {  
            subscriptions = new CopyOnWriteArrayList<>();  
            //根据事件类型来存储所有订阅信息（事件 --- 订阅信息）
            //一个EventType可能对应很多个方法和对象，然后就把他们存储起来
            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) {  
                //把订阅的这个订阅信息 存储到 该事件类型的 list 中
                subscriptions.add(i, newSubscription);  
                break;  
            }  
        }  

        // 获取该订阅者的订阅事件list
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);  
        if (subscribedEvents == null) {  
            subscribedEvents = new ArrayList<>();  
            // 根据订阅者来存储订阅方法 （订阅者 --- 事件）
            //一个订阅者可能有多个订阅方法，但是每个订阅方法可能会是不同的EventType
            typesBySubscriber.put(subscriber, subscribedEvents);  
        }  
        subscribedEvents.add(eventType);  

        // 处理粘性事件
        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);  
            }  
        }  
    }

Subscription 类，封装了订阅者和一个订阅方法

final class Subscription {  
    final Object subscriber;  
    final SubscriberMethod subscriberMethod;  
    /** 
     * Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery 
     * {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions. 
     */  
    volatile boolean active;
    //...
}

3、 发布订阅事件

post(Object event) 

public void post(Object event) {  
       PostingThreadState postingState = currentPostingThreadState.get();  
       //拿到发布事件线程的事件队列
       List<Object> eventQueue = postingState.eventQueue;  
       eventQueue.add(event);  

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

PostingThreadState 类

final static class PostingThreadState {  
       final List<Object> eventQueue = new ArrayList<Object>();  
       boolean isPosting;  
       boolean isMainThread;  
       Subscription subscription;  
       Object event;  
       boolean canceled;  
}

postSingleEvent（）方法会调用 postSingleEventForEventType（）方法来真正地发布事件。

发布步骤是：
1、根据事件类型来获取订阅信息（一个订阅信息存储了一个订阅者和它的一个订阅方法）
2、然后根据订阅信息把事件发布给这些订阅者的订阅方法

postSingleEventForEventType 意为根据事件类型来发布事件，实现如下：

    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {  
            CopyOnWriteArrayList<Subscription> subscriptions;  
            synchronized (this) {  
                // 1、根据事件类型来获取订阅信息
                subscriptions = subscriptionsByEventType.get(eventClass);  
            }  
            if (subscriptions != null && !subscriptions.isEmpty()) { 
                // 2、把事件发布给这些订阅者的订阅方法 
                for (Subscription subscription : subscriptions) {  
                    postingState.event = event;  
                    //根据订阅信息来发布事件
                    postingState.subscription = subscription;  
                    boolean aborted = false;  
                    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;  
}

发布方法 postToSubscription 如下，根据ThreadMode来在不同的线程中发布事件。

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 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);  
       }  
}

invokeSubscriber 方法如下：

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);  
       }  
}

我们来看下 backgroundPoster.enqueue(subscription, event); 的 enqueue 方法：

public void enqueue(Subscription subscription, Object event) {  
      PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);  
      synchronized (this) {  
          queue.enqueue(pendingPost);  
          if (!executorRunning) {  
              executorRunning = true;  
              // 交给线程池来执行
              eventBus.getExecutorService().execute(this);  
          }  
      }  
}

最后线程执行，调用了 backgroundPoster的run方法。

@Override  
public void run() {  
    try {  
        try {  
            while (true) {  
                PendingPost pendingPost = queue.poll(1000);  
                if (pendingPost == null) {  
                    synchronized (this) {  
                        // Check again, this time in synchronized  
                        pendingPost = queue.poll();  
                        if (pendingPost == null) {  
                            executorRunning = false;  
                            return;  
                        }  
                    }  
                }  
                // 最终还是利用反射
                eventBus.invokeSubscriber(pendingPost);  
            }  
        } catch (InterruptedException e) {  
            Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);  
        }  
    } finally {  
        executorRunning = false;  
    }  
}

简单总结事件能被订阅者接收到的主要步骤：

一、注册订阅者

  1. 获取订阅者的订阅方法
    根据是否开启订阅者索引优化来选择获取订阅方法的策略
    如果开启：使用订阅者索引获取
    如果没有：使用反射
  2. 将获取到的订阅方法注册
    根据 EventType 将对应的订阅方法列表使用 map 保存起来完成注册
    map 结构如下（key – value）
    事件类型 ——— 订阅信息（一个订阅者和它的一个订阅方法）列表

二、post 发布事件

  1. 拿到发布事件线程的事件队列
  2. 往队列里面添加事件
  3. 依次取出队列里面的的事件进行发布
    根据事件的类型来获取对应订阅信息列表
    根据订阅信息使用反射调用订阅方法，并把事件传递给订阅方法
Rogera7
关注
专栏目录
Android面试之EventBus原理分析
itbird的专栏
09-23 1793
众所周知，EventBus 是一款用在 Android 开发中的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分开，简化了组件之间的通信操作，使用简单、效率高、体积小！EventBus使用了典型的发布/订阅事件模式，下面是 EventBus官方给出的原理示意图。
事件总线框架EventBus的使用与原理解析
热门推荐
老蒋也疯狂
12-21 1万+
文章目录1. EventBus框架1.1 EventBus简介1.2 EventBus基本使用1.2.1 添加Gradle依赖1.2.2 定义事件1.2.3 准备订阅者1.2.4 发布事件2. EventBus原理解析2.1 订阅者注册过程2.2 订阅者注销过程2.3 事件发布过程3. EventBus性能优化  事件总线模式基于发布-订阅机制实现，它是一种集中式事件处理机制，允许不同的组件之间进...
【android】EventBus原理
chandelierr的博客
09-03 1628
在公司实习，小组的项目使用到这个框架，尽管一直在使用，很顺手很好用，但是不怎么明白里面的原理，赶着最近准备找工作，总结一下吧。EventBus–ReadMe必然要先从官方文档开始，最然看不怎么懂，但是看看官方的总结还是很有用的。EventBus is a publish/subscribe event bus optimized for Android.EventBus 是一个针对Android优化
EventBus 原理解析
weixin_33885676的博客
04-27 822
EventBus 是一款在 Android 开发中使用的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分开，简化了组件之间的通信，使用简单、效率高、体积小！下边是官方的 EventBus 原理图： EventBus 的用法可以参考官网，这里不做过多的说明。本文主要是从 EventBus 使用的方式入手，来分析 EventBus 背后的实现原理，以下内容基于eventbus:3.1...
EventBus原理
guodashen007的博客
09-14 300
1、在register的时候，Eventbus类通过反射的方式，获取注册对象的所有带有@Subscribe注解的接收方法，不能是static和非public的，同时数据参数只有一个， 然后放到一个列表中。（如果在类中找不到接收方法，将会报异常） 2、发消息的地方，post方法，通过PostingThreadState 进行消息的分发，分发消息就是查找列表中是否有符合参数要求的对象，然后通过反射的消息，invoke调用对应对象的方法。 3、在postToSubscription方法中，会区分事件的类型..
EventBus 原理简化分析版
02-03
总结来说，EventBus 提供了一种简单、高效的方式来在 Android 应用的不同组件之间传递信息，降低了代码的耦合度，并简化了事件处理逻辑。理解和熟练运用 EventBus 可以显著提升 Android 开发效率和代码质量。
Node.js-Eventbus3.0简单使用适合初学者使用
08-12
Eventbus的工作原理是：发布者通过`eventbus.publish`方法发布事件，订阅者通过`eventbus.on`或`eventbus.once`来监听并处理这些事件。 ### 发布事件 在发布者模块中，引入`eventbus`并发布事件。例如，当用户登录...
Android 认识EventBus到原理解析
csdn_aiyang的博客
05-11 686
目录 一、添加gradle依赖 二、基础操作 1、EventBus.getDefault(); 2、EventBus.getDefault().register(this); 3、EventBus.getDefault().post(object); 4、EventBus.getDefault().unregister(); 二、四个onEvent方法 三、Ev...
eventbus原理
shuangrenlong的博客
07-23 150
https://www.jianshu.com/p/d9516884dbd4 根据上面的讲解 来简化原理 EventBus.getDeafault.register(this) 1.传入对象，利用反射得到消息回调的方法列表 2.这些方法循环与对象绑:主要干了两件事情，加入两个map a.第一个map subscriptionsByEventType (evnetType list<Subscription(sucriber, method)>) 方法的参数也就是消息类型.
EventBus 原理简析
alcoholdi的专栏
09-02 1230
基于eventbus:3.1.1 分析。 一.注解写法 关键字是@Subscribe 后面括号内可选参数是，threadMode表示可以选择切换到哪个线程。sticky是否粘性事件，priority表示优先级。 ThreadMode: POSTING 表示发送事件的线程，当前线程。 ThreadMode: MAIN 表示UI线程 ThreadMode: MAIN_ORD...
EventBus 原理浅析
xzwhappycj的专栏
02-18 274
EventBus是基于方法注解和观察者模式实现的。 EventBus 实现消息通信过程包括三个部分: register(注册)、post(发送消息)和unregister(注销) 1.register，注册是将订阅者与其感兴趣的事件进行关联的过程。 通过调用EventBus的register()方法实现，register方法主要做了三件事： (1)通过反射的方式查找suscriber中所...
EventBus的原理解析
最新发布
qq_27391737的博客
01-18 490
EventBus是一种发布-订阅事件总线。它有三大要素：Event:事件、Publisher:发布者,可以在任意线程发布事件、Subscrible:订阅者。下面就让从注册开始慢慢揭开EventBus的神秘面纱。追踪getDefault方法，我们可以清楚的看到它是通过双重判空创建了一个EventBus对象，我们继续往下追在初始化中创建了部分的参数，我们下面会着重分析下subscriptionsByEventType、typesBySubscriber 、stickyEvents。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值