EventBus详解

已于 2024-04-15 00:25:38 修改
阅读量357 收藏 1
点赞数
文章标签： java 开发语言 android
于 2020-08-04 10:54:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xd0123456789/article/details/107779927
版权

EventBus使用

普通使用(先注册 在发送)

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

    EventBus.getDefault().register(this);

}
  2. 解注册 
    @Override
protected void onDestroy() {
    super.onDestroy();
    EventBus.getDefault().unregister(this);
}
  3. 创建事件类 
    public class MessageEvent {
    public String name;
    public String password;

    public MessageEvent(String name, String password) {
        this.name = name;
        this.password = password;
    }
}
  4. 发送消息 
    EventBus.getDefault().post(new MessageEvent("123","123456"));
  5. 接受处理消息 
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void messageEventBus(MessageEvent event){
        tv_result.setText("name:"+event.name+" passwrod:"+event.password);
    }

粘性使用（先发送 在注册的时候处理事件）

  1. 构建事件类 
    public class StickyEvent {
    public String msg;

    public StickyEvent(String msg) {
        this.msg = msg;
    }
}
  2. 发送消息 
    EventBus.getDefault().postSticky(new StickyEvent("我是粘性事件"));
  3. 接受处理消息 
       @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);

EventBus源码详解

单例模式，具体初始化在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;
}

提供了公共的构造方法，属实有点难以理解（可提供多条事件）

public EventBus() {
    this(DEFAULT_BUILDER);
}

具体初始化流程

EventBus(EventBusBuilder builder) {
    logger = builder.getLogger();
    subscriptionsByEventType = new HashMap<>();
    typesBySubscriber = new HashMap<>();
    stickyEvents = new ConcurrentHashMap<>();
    mainThreadSupport = builder.getMainThreadSupport();
    mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
    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;
}
Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType; 存储事件类型 订阅方法和订阅类
Map<Object, List<Class<?>>> typesBySubscriber  存储订阅事件和订阅类

线程相关操作类

private final MainThreadSupport mainThreadSupport;  主线程操作类，将事件发生到主线程
private final Poster mainThreadPoster;
private final BackgroundPoster backgroundPoster;  后台线程操作类，将事件发生到后台线程
private final AsyncPoster asyncPoster;  后台线程操作类

注册事件

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. 获取注册类中的订阅方法，保存在subscriberMethodFinder 
    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);//在缓存中查找
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    if (ignoreGeneratedIndex) {//默认为false
        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;
    }
}
解释：Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
  2. 将当前订阅者添加到EventBus总的事件中subscribe(subscriber, subscriberMethod) 
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;//获取事件类型
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//根据事件类型，获取所有的相关的Subscription
    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);
    }
    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);
        }
    }
}
  3. 将当前订阅者所有订阅的事件类型添加到typesBySubscriber

发送事件

普通发送

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

//发送事件

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;
    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));
        }
    }
}

//对事件线程切换，使用到了HandlerPoster extends Handler implements Poster类

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);
    }
}
  1. 粘性发送（将粘性事件保存，在注册事件的时候进行判断，如果是粘性事件则 
    checkPostStickyEventToSubscription(newSubscription, stickyEvent);，后去事件处理和普通事件一值）
    public void postSticky(Object event) {
    synchronized (stickyEvents) {
        stickyEvents.put(event.getClass(), event);
    }
    // Should be posted after it is putted, in case the subscriber wants to remove immediately
    post(event);
}

解注册事件

//通过typesBySubscriber获取当前订阅者的所有事件类型

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 {
        logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

//遍历事件类型，并在总事件中删除当前订阅者的订阅方法

private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
    List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions != null) {
        int size = subscriptions.size();
        for (int i = 0; i < size; i++) {
            Subscription subscription = subscriptions.get(i);
            if (subscription.subscriber == subscriber) {
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}

EventBus流程图

EventBus: 💢 Nepxion EventBus is a generic event dispatching component based on Google Guava with Spring framework AOP, support synchronous and asynchronous mode 基于Google Guava通用事件派发机制的事件总线组件，注解式发布订阅

xd0123456789
关注
Vue—EventBus详解
雷雨天的雷胖子
10-03 1295
一、概述 Vue组件之间的数据共享问题，针对不同情景，有不同的解决方案。如简单父子组件通信，可以使用props，项目比较复杂，则组件通信可以使用Vuex。对于简单的非父子组件通信，没必要使用Vuex时，可以考虑使用EventBus解决。EventBus又称为中央事件总线，可以作为组件之间沟通的桥梁，作为组件之间共享的事件中心。 二、创建中央事件总线 方法一：main.js中注册全局的事件总线 import Vue from 'vue'; Vue.prototype.$eventBus = n
Android事件总线还能怎么玩？
愤怒的油条
04-22 998
摘要：Android事件总线框架AndroidEventBus简化了Activity、Fragment、Service等组件之间的交互，让代码更简洁，耦合性更低，但它能做的却不仅限于这些，经过定制，它能够完成很多有意思的功能。 顾名思义，AndroidEventBus是一个Android平台的事件总线框架，它简化了Activity、Fragment、Service等组件之间的交互，很大程
EventBus使用详解教程，带你学习eventbus。详解Demo
09-06
注意事项遇到问题请看：http://blog.csdn.net/qq_21376985/article/details/52438143
EventBus优化发布订阅事件详解
Cloud_Ling的专栏
04-09 2214
一、概述 EventBus是一款针对Android优化的发布/订阅事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。 1、下载EventBus的类库 源码：https://github.com/greenrobot/EventBus 2、
EventBus详解 (详解 + 原理)
最新发布
m0_49508485的博客
11-10 4万+
EventBus简介EventBus是一个开源库，由GreenRobot开发而来，是用于Android开发的 “事件发布—订阅总线”，用来进行模块间通信、解藕。它可以使用很少的代码，来实现多组件之间的通信。Android系统中的事件通信则是 handler (消息机制) 和 BroadCastReceiver (广播机制)，通过它们可以实现组件之间的事件通讯。缺点在于，代码量多、组件之易产生藕合引用。EventBus产生的背景。
EventBus详细解析
潇湘夜雨
11-23 461
1. 功能介绍 1.1 EventBus EventBus 是一个 Android 事件发布/订阅框架，通过解耦发布者和订阅者简化 Android 事件传递，这里的事件可以理解为消息，本文中统一称为事件。事件传递既可用于 Android 四大组件间通讯，也可以用户异步线程和主线程间通讯等等。 传统的事件传递方式包括：Handler、BroadCastReceiver、Interfac
Android第三方框架EventBus使用详解
FynnJason的技术屋
11-29 1166
EventBus使用详解(一)——EventBus核心内容 目录 概述实战 基本框架搭建新建一个类FirstEvent在要接收消息的页面注册EventBus发送消息接收消息 一、概述 当一个Android应用功能越来越多的时候，保证应用的各个部分之间高效的通信将变得越来越困难。所以为了解决这个问题，EventBus应运而生！ EventBus是一款针对Android
EventBus详解示例Demo
07-14
**EventBus详解** EventBus是一款轻量级的事件总线库，它简化了Android应用中的组件间通信。在传统的Android开发中，我们通常使用接口回调、BroadcastReceiver或静态内部类来实现组件间的通信，但这些方式往往使得...
android eventbus fragment,Eventbus 详解，fragment 和 Activity相互发送接收数据
weixin_34990053的博客
05-27 915
最近，需要做fragment与activity的交互，但是，又不想使用回调接口，所以想到了EventBus.大致了解了一下其主要介绍为：一款针对Android优化的发布/订阅事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。在程序中，Fragment与A...
Google Guava库中的EventBus详解
# 1. Google Guava简介 Google Guava是Google公司开发的一套基于Java语言的开源库，旨在提供高质量的Java核心库扩展，包括集合、缓存、原生类型支持、并发库、通用注解、字符串处理、I/O等功能。...
博客《 EventBus使用详解（一）——初步使用EventBus》对应源码
11-02
博客《 EventBus使用详解（一）——初步使用EventBus》对应源码，博客地址：http://blog.csdn.net/harvic880925/article/details/40660137
Android之事件总线EventBus详解
码莎拉蒂
12-02 2171
顾名思义，AndroidEventBus是一个Android平台的事件总线框架，它简化了Activity、Fragment、Service等组件之间的交互，很大程度上降低了它们之间的耦合，使我们的代码更加简洁，耦合性更低，提升了我们的代码质量。但它能做的却不仅限于这些。经过定制，它能完成很多有意思的功能，那么究竟该怎么做呢？就让我们一起往下看吧。       不堪回首的痛
EventBus学习笔记
snow_Lu的博客
05-18 269
EventBus是一款针对Android优化的发布/订阅事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。 源码的地址：https://github.com/greenrobot/EventBus   EvenBus使用方式：
EventBus的详解
qq_21709259的博客
10-12 398
EventBus是一个Android端优化的publih/subcribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现。 EventBus最大的优点是代码的可读性非常好，耦合度很低！ EventBus使用三个要素：
EventBus
xiangkezhu的博客
01-04 212
  三要素： 1.event 2.subscriber 3.publisher 四种线程模型: 1.POSTING (默认) 表示事件处理函数的线程跟发布事件的线程在同一个线程 2.MAIN 表示事件处理函数的线程在主线程(UI)线程 3.BACKGROUND 表示事件处理函数的线程在后台线程 4.ASYNC 表示无论事件发布的线程是哪一个，事件处理函数始终会新建一个子线程运行 ...
Android中EventBus原理及用法详情
移动开发Android
09-09 799
EventBus概述EventBus是一款针对Android优化的发布/订阅（publish/subscribe）事件总线。主要功能是替代Intent,Handler,BroadCast在Fragment，Activity，Service，线程之间传递消息。简化了应用程序内各组件间、组件与后台线程间的通信。优点是开销小，代码更优雅。以及将发送者和接收者解耦。比如请求网络，等网络返回时通过Handle
EventBus详解：注册、响应与源码解析
在Android开发中，EventBus是一个流行的消息发布/订阅库，它简化了组件之间的通信，避免了过度依赖于Activity或Fragment的生命周期。以下是EventBus的详细知识点： 1. 注册: 使用`EventBus.getDefault().register...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值