EventBus 源码分析

最新推荐文章于 2022-03-25 13:44:37 发布
最新推荐文章于 2022-03-25 13:44:37 发布
阅读量236 收藏
点赞数
分类专栏： # Android 源码分析 文章标签： EventBus源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14876133/article/details/107484764
版权

文章目录

EventBus分析

EventBus执行流程分析

EventBus基本使用

//在Activity里使用EventBus

@Override
protected void onStart() {
    super.onStart();
    //注册
    EventBus.getDefault().register(this);
}

public void btnClick(View v) {
    //发布事件
    EventBus.getDefault().post(new MessageEvent<String>(100, "hello 这是一条普通事件"));
}

//订阅方法
@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(MessageEvent<String> event) {
    if (event.getCode() == 100) {
        tv_msg.setText(event.getData());
    }
}

//订阅方法
@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(MessageEvent2<String> event) {
    if (event.getCode() == 100) {
        tv_msg.setText(event.getData());
    }
}

@Override
protected void onStop() {
    super.onStop();
    //反注册
    EventBus.getDefault().unregister(this);
}

事件流向

EventBus事件流向

订阅者和订阅事件关系

上面的代码里，订阅者subscriber是Activity，监听了两个事件MessageEvent和MessageEvent2，当发布事件后，会收到2个数据。

订阅者通过register()方法注册，一个订阅者可以对应多个事件，通过一个Map结构维护。

private final Map<Object, List<Class<?>>> typesBySubscriber;

订阅者和订阅事件关系

订阅事件和订阅者关系

在Android中，一个事件可能被多个subscriber订阅，当发布事件时，会查找所有订阅了该事件的subscriber，并调用其中的event方法，通过一个Map结构维护。

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

订阅事件和订阅者关系

粘性事件关系

发布的粘性事件会将事件类型和事件保存在一个Map结构中，注册时订阅消息会从stickyEvents取出消息并执行。

private final Map<Class<?>, Object> stickyEvents;

粘性事件

EventBus源码分析

EventBus核心属性

//key为订阅者对象，value为订阅事件类型集合(Event类型)
private final Map<Object, List<Class<?>>> typesBySubscriber;

//订阅信息类，包含订阅者对象和订阅方法
final class Subscription {
    final Object subscriber;
    final SubscriberMethod subscriberMethod;
}

//key为事件类型，value为Subscription对象
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

//key为订阅者的class对象，value为订阅者中的所有订阅方法
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();

注册

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

EventBus#register()

//注册订阅者
public void register(Object subscriber) {
    //获取的class对象
    Class<?> subscriberClass = subscriber.getClass();

    //获得注册类的所有订阅方法
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

    //遍历订阅方法
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            //关联注册类和订阅方法
            subscribe(subscriber, subscriberMethod);
        }
    }
}

SubscriberMethodFinder#findSubscriberMethods()

//获取所有订阅方法
//必须是@Subscribe注解，public修饰，一个参数
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //先从缓存中获取订阅方法
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    //ignoreGeneratedIndex默认为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;
    }
}

SubscriberMethodFinder#findUsingInfo()

//若findState缓存订阅方法信息，则使用findState里的缓存，否则调用findUsingReflectionInSingleClass()获取订阅方法信息
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
    //获取一个存储对象findState
    FindState findState = prepareFindState();
    //findState存储订阅者的class对象
    findState.initForSubscriber(subscriberClass);
    
    //findState.clazz就是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.clazz为subscriberClass的父类的class对象
        findState.moveToSuperclass();
    }
    
    //返回findState中保存的订阅方法，并释放findState
    return getMethodsAndRelease(findState);
}

SubscriberMethodFinder#findUsingReflectionInSingleClass()

//通过反射获取订阅方法的信息
private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        //获取订阅者中的所有方法
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        ...
    }

    //遍历方法
    for (Method method : methods) {

        //获取方法的修饰符
        int modifiers = method.getModifiers();

        //方法是public类型，但是不能是abstract、static等
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {

            //获取方法中的的所有参数类型
            Class<?>[] parameterTypes = method.getParameterTypes();

            //判断参数个数，只能有1个参数
            if (parameterTypes.length == 1) {

                //获取方法有@Subscribe的注解
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);

                //若方法有@Subscribe注解，则就是订阅者中的订阅方法
                if (subscribeAnnotation != null) {
                    //获取订阅方法中的第一个参数类型，依旧是订阅的事件类型
                    Class<?> eventType = parameterTypes[0];
                    //checkAdd用于判断FindState是否添加过该事件
                    if (findState.checkAdd(method, eventType)) {
                        //获取线程模式
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        //将订阅方法中的信息（如：订阅方法、事件类型、线程模式、优先级、粘性事件等）封装成SubscriberMethod对象，并保存到到findState中的subscriberMethods集合里
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode, subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }

            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                //参数个数超过1个时，抛出异常
                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)) {
            //方法的修饰符不是public时，抛出异常
            String methodName = method.getDeclaringClass().getName() + "." + method.getName();
            throw new EventBusException(methodName + " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
        }
    }
}

SubscriberMethodFinder#getMethodsAndRelease()

private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
    //获取findState中的subscriberMethods
    List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
    findState.recycle();
    synchronized (FIND_STATE_POOL) {
        for (int i = 0; i < POOL_SIZE; i++) {
            if (FIND_STATE_POOL[i] == null) {
                FIND_STATE_POOL[i] = findState;
                break;
            }
        }
    }
    //返回集合
    return subscriberMethods;
}

EventBus#subscribe()

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

    //将订阅者和订阅方法封装成一个Subscription对象
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

    //subscriptionsByEventType是HashMap结构，key为事件类型，value为Subscription对象
    //获取该事件的所有订阅者信息
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);

    //若不存在
    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);
        }
    }

    //添加newSubscription对象到subscriptions集合中
    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;
        }
    }

    //typesBySubscriber是HashMap结构，key为订阅者对象，value为事件集合
    //获取该订阅者的事件集合
    List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    //添加到集合中
    subscribedEvents.add(eventType);

    //是否支持粘性事件
    if (subscriberMethod.sticky) {
        if (eventInheritance) {
            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#unregister()

public synchronized void unregister(Object subscriber) {
    //获取当前订阅者的所有事件类型集合
    List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
    //若集合不为null
    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());
    }
}

EventBus#unsubscribeByEventType()

//解除事件订阅
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
    //根据当前事件类型，获取订阅者集合
    List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    //若集合不为null
    if (subscriptions != null) {
        int size = subscriptions.size();
        //遍历订阅者集合
        for (int i = 0; i < size; i++) {
            //获取Subscription对象，该对象包含订阅者对象和订阅方法的所有信息
            Subscription subscription = subscriptions.get(i);
            //若找到该订阅者，则移除订阅者
            if (subscription.subscriber == subscriber) {
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}

发布事件

EventBus#post()

//发布事件
public void post(Object event) {
    //获取当前线程的PostingThreadState对象
    //postingState对象包含：事件队列、线程状态、是否正在发送的标识等
    PostingThreadState postingState = currentPostingThreadState.get();
    
    //获取事件队列
    List<Object> eventQueue = postingState.eventQueue;
    
    //将事件加入到事件队列中
    eventQueue.add(event);

    //当前事件是否正在发送
    if (!postingState.isPosting) {
        //是否在主线程
        postingState.isMainThread = isMainThread();
        //isPosting设置为true
        postingState.isPosting = true;
        //是否取消
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        
        try {
            //遍历队列，队列不为null，进入循环
            while (!eventQueue.isEmpty()) {
                //分发事件
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            //重置状态
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}

EventBus#postSingleEvent()

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    //获取事件对象的class
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;

    //是否查看所有的继承关系
    if (eventInheritance) {
        //lookupAllEventTypes()获取父类的所有事件类型
        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);
        }
        
        //若没有订阅事件，则发送NoSubscriberEvent
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class && eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

EventBus#postSingleEventForEventType()

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?>  eventClass) {

    CopyOnWriteArrayList<Subscription> subscriptions;
    synchronized (this) {
        //获取当前事件的所有订阅者
        subscriptions = subscriptionsByEventType.get(eventClass);
    }

    //若集合不为null
    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;
}

EventBus#postToSubscription()

//处理事件
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    //根据EventBus线程模式处理对应事件
    switch (subscription.subscriberMethod.threadMode) {          
        case POSTING:
            //默认线程模式，在哪个线程发送事件，就在哪个线程处理事件
            //直接通过反射执行
            invokeSubscriber(subscription, event);
            break;          
        case MAIN:
            //如果是主线程，则直接执行，如果是子线程，则通过Handler切换主线程执行
            if (isMainThread) {
                //主线程中，直接通过反射执行
                invokeSubscriber(subscription, event);
            } else {
                //通过Handler切换到主线程，在进行处理
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case MAIN_ORDERED:
            //无论哪个线程，都先加入队列后，通过Handler执行
            if (mainThreadPoster != null) {
                mainThreadPoster.enqueue(subscription, event);
            } else {
                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);
    }
}

EventBus#postSticky()

//发布粘性事件
public void postSticky(Object event) {
    synchronized (stickyEvents) {
        //将事件类型和事件放入stickyEvents中
        stickyEvents.put(event.getClass(), event);
    }
    post(event);
}

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {

    //...

    //判断订阅方法是否粘性事件
    if (subscriberMethod.sticky) {
        //是否查找父类
        if (eventInheritance) {
            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);
        }
    }
}

优秀博客

https://juejin.im/post/5e981905518825085d6d0164#heading-3

https://juejin.im/post/5da97188e51d4524a21c481f#heading-2

xiangxiongfly915
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
EventBus源码分析
海的鼻涕的博客
09-24 1107
相信大家都有在项目中使用过EventBus。EventBus是一个性能高效的基于观察者模式的事件发布与订阅框架。借助EventBus，我们只需几行代码便能实现组件之间、线程之间的通信，达到解耦的目的。这篇文章不对EventBus的使用进行介绍，而是格物致知，探究EventBus的源码。
EventBus学习源码
12-18
本文将深入探讨 EventBus 的源码，帮助你理解其工作原理。 首先，我们要了解 EventBus 的核心概念：发布（Posting）、订阅（Subscribing）和粘性事件（Sticky Events）。发布是通过调用 `EventBus.getDefault()....
EventBus.getDefault().post()
weixin_41733225的博客
04-20 3538
EventBusPostActivity向已启动的FirstActivity发送post 流程：FirstActivity启动EventBusPostActivity，然后EventBusPostActivity向FirstActivity发送EventBus关闭FirstActivity 依赖 implementation 'org.greenrobot:eventbus:3.0.0' 序列化基类 public class BaseEntity implements Serializable { }
EventBus使用详解(二)——EventBus使用进阶
热门推荐
启舰
11-04 13万+
前言：这段时间感觉自己也有点懒了，真是内心有点自责呢，除了工作，也没做点什么，EventBus也是一周前总结出来的，只能以写博客为名来弥补内心的罪恶感了，集合同事们做的项目，虽然上周开动了，但总感觉大家积极性不高，如何才能做一个合格的管理者，还真是一个考验。follow your heart!! just do it! 相关文章： 1、《EventBus使用详解(一)——初步使用E...
EventBus.getDefault().postSticky()
weixin_41733225的博客
04-20 1353
v sjdkv
EventBus 普通事件的post
相公
10-05 1224
EventBus 普通事件的post 当订阅事件完成后，就需要发送时间通知了，调用比较简单 EventBus.getDefault().post(eventType); 看一下post事件： /** Posts the given event to the event bus. */ public void post(Object event) { PostingThre...
EventBus源码及demo
09-07
在 "EventBus源码及demo" 中，我们可以深入理解 EventBus 的工作原理以及如何在实际应用中使用。 **1. EventBus 的基本概念** EventBus 提供了一种基于发布/订阅的事件传递机制。发布者（Publisher）发布事件，订阅...
eventBus 3.0 带有注释的源码
05-31
源码分析主要涉及以下几个核心知识点： 1. **发布与订阅（Posting and Subscribing）**： - 发布事件（Posting Events）：EventBus 提供了 `post()` 方法来发布自定义事件对象。这些事件可以是任何 Java 对象，但...
EventBus3.0源码解析.md
08-12
基于Eventbus3的源码分析 从初始化到注册、post、接收、注销的一系列流程分析 文件为markdown
android开源框架源码分析
12-11
EventBus 源码分析 EventBus 是一个非常流行的 Android 事件总线框架，它提供了一种简单的方式来处理事件之间的通信。EventBus 的工作过程可以用一句话来概括：事件被提交到 EventBus 后，进行查找所有订阅该事件的...
EventBus躲坑日记 EventBus.getDefault().post()中post参数不能使用int类型
jifenglie的博客
05-13 7022
EventBus.getDefault().post() post 中参数不能使用int类型的值，String类型可以；不然 根本获取不到事件 @Subscribe(threadMode = ThreadMode.MAIN) // public void onMessageEvent(int model_update) { // if (model_update ==...
Android为TV端助力 EventBus.getDefault()开源框架
weixin_30652879的博客
02-23 172
在onCreate里面执行 EventBus.getDefault().register(this);意思是让EventBus扫描当前类，把所有onEvent开头的方法记录下来，如何记录呢？使用Map，Key为方法的参数类型，Value中包含我们的方法。 这样在onCreate执行完成以后，我们的onEventMainThread就已经以键值对的方式被存储到EventBus中了。 然后当子线程...
android实用教程源码,Android EventBus3.0+ 简单使用及源码讲解
weixin_30531679的博客
05-29 118
前言EventBus3.0之后添加了一项新功能——订阅者索引，该功能不是强制使用的，若是我们只导入implementation 'org.greenrobot:eventbus:3.1.1'是不能够使用索引的。该功能是在项目编译时生成索引文件，项目运行时执行这些文件，以达到提高运行速度的目的，因为在不使用索引功能情况下，使用的是反射，因此要耗时一些。本文就主要分析EventBus在不使用索引功能的...
Android事件总线AndroidEventBus的使用
大前端程序猿
04-23 3462
今天学了了一个开源框架AndroidEventBus，该框架主要针对不同组件间的通信，如Activity、Fragment、Service等，在没有AndroidEventBus前，我们如果需要在不同的Activity或Fragment间通信，一般会选择使用广播来处理，在某个Activity中注册广播，在另一个Activity中发送广播，这么做虽然可以达到通信的目的，但是编码起来非常繁琐，Andr
EventBus的简单使用
紫微星的博客
03-25 4924
不愧是我
android eventbus view,Android-EventBus框架详细介绍与简单实现
weixin_42481553的博客
05-29 233
常用事件消息传递一个实现了监听器接口的类，必须把它自身注册到它想要监听的类中去使用广播，内部的实现都需要IPC(进程间通信)，从传递效率上来讲，可能并不太适合上层的组件间通信Activity间的消息传递便是通过startActivityForResult和onActivityResult，会产生较多的状态或者逻辑判断，而且Intent或者Bundle传值还得监测类型，容易发生错误EventBus概...
Android框架源码分析——EventBus
浅谈Android
04-26 305
1、介绍篇 EventBus三要素 Event 事件：可以是任意类型，既然为事件一定伴随着传递和操作，在使用中扮演信息和事件载体 Subscriber 事件订阅者：这里的订阅着和RxJava中作用一样负责监听某种状态，在状态和条件改变时回调处理，在EventBus3.0之前所有的订阅方法必须是onEvent开头，分别是onEvent、onEventMainThread、onEventBack...
EventBus简单使用以及源码分析
massonJ的博客
08-08 308
吐槽一下，这个简书的编辑功能太不友好了，不能像word一样快捷键点击，还需要自己一点一点按格式抠。。。。 吐槽完毕，之前源码分析都在自己的本地，没有传到网上，因为很多网上都有，这次尝试搬到网上，但是这个编辑功能太费劲，全搬上来估计格式问题就得调很久，还是不搬了。 基本使用： 添加依赖： implementation 'org.greenrobot:eventbus:3.1.1' EventBus的注册： EventBus.getDefault().register(this); 事件的发送： 普通事件的
EventBus源码解析03-事件的发送
朱豪凯的博客
08-26 516
接着来看EventBus的事件发送过程 EventBus.getDefault().post(message); 通过post()可以对事件进行发送。 public void post(Object event) { //通过currentPostingThreadState这个ThreadLocal创建PostingThreadState，解决线程并发的问题 Posting
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值