继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

EventBus详解及源码分析

仰简
关注TA
已关注
手记 20
粉丝 4
获赞 29

一、前言

从 EventBus 的介绍中,EventBus 给的定位是:

Event bus for Android and Java that simplifies communication between Activities, Fragments, Threads, Services, etc. Less code, better quality

简单理解一下就是 Event bus 给 Android 及 Java (当然主要是 Android)的 Activity,Fragment,Threads,Services 之间提供一个简单的通信方式,从而能让我们用质量高且少的代码来完成我们的功能。

二、EventBus 详解之官文解读

2.1 架构概述

EventBus 是一个基于发布/订阅的设计模式的事件总线,其架构图如下。

从架构图上来看,还是很简单的,跟我们所最熟悉的观察者模式是类似的。大概工作过程就是:
(1) Subscriber 也就是订阅者,订阅一个 Event,其中 Event 是自己定义的,符合 POJO 的规范即可。
(2) 在需要时,Publisher 也就是发布者,就可将事件通过 EventBus 分发布相应的订阅者 Subscriber。

恩,就是如此简单。当然,其实现远不会这么简单了,还是干了很多脏活和累活的。

2.2 特性概述

  • 简化了组件之间的通信
    • 事件发送者和接收者分离
    • 在Activity,Fragment和后台线程中都可以很好的进行事件的分发
    • 避免复杂且容易出错的依赖关系和生命周期问题
  • 简化代码
  • 快,多快呢?
  • 小(约50k)
  • 已经通过100,000,000+安装的应用程序在实践中得到证实
  • 具有指定分发线程,优先级等高级功能。

2.3 功能概述

  • 事件订阅 / 分发
    这是其最核心的功能,也是要在源码分析中需要深入的。
  • 指定分发线程 Delivery Threads (ThreadMode)
    即指定订阅者将在哪个线程中响应事件的处理。恩,这主要用于如网络或者耗时的线程处理,需要切换到主线程来更新 UI 的场景。当然,如果用 RxJava 的话,这个就再熟悉不过了。
  • 配置 Configuration
    通过 EventBusBuilder 类对 EventBus 进行各方面的配置,如配置可允许事件的分布没有订阅者处理,而不报异常。
  • 粘性事件 Sticky Events
    将用户发送过的事件暂时保存在内存中,当订阅者一旦订阅了该事件,就可以立即收到该事件。恩,这个就与粘性广播的概念是一致的了。
  • 优先级以及取消事件
    主要是指定 Subscriber 的优先级,其默认优先级为 0,指定了较高的优先级就可以优先收到事件进行处理。而收到事件的 Subcriber 中提前取消事件的继续分发,从而中断事件的继续分发。恩,这个也跟广播里的 abortBroadcast 概念一样。
  • Subscriber Index
    用中文不知道咋说。这个是 3.0 的版本加的,主要是将事件处理中的对事件的反射处理,提前到编译时来处理了。从而提高性能。当然,主要也是推荐在 Android 下使用。
  • 异步执行器 AsyncExecutor
    主要就是一个线程池,可以理解就是一个帮助类。

三、源码解析

3.1 开始向导

EventBus 的官方文档为我们提供了经典的使用 EventBus 的 3 个过程。

3.1.1定义事件

普通的 POJO 即可

public class MessageEvent {
 
    public final String message;
 
    public MessageEvent(String message) {
        this.message = message;
    }
}

3.1.2 准备订阅者

文章是基于 EventBus 3 进行分析,对于订阅者的方法命名可以自由命名了,而不需要采用约定命名。

@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}
 
// This method will be called when a SomeOtherEvent is posted
@Subscribe
public void handleSomethingElse(SomeOtherEvent event) {
    doSomethingWith(event);
}

准备好了订阅者之后,我们还需要向总线注册这个订阅者,这个我们的订阅者方法才能接收到相应的事件。

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}
 
@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

3.1.3 发送事件

我们可以在任何地方发送事件。

EventBus.getDefault().post(new MessageEvent("Hello everyone!"));

3.2 源码解析

根据前文的 3 步经典使用方法,源码的分析大概也分成如下 4 步来进行。

3.2.1 注册订阅者

图片描述

如上面的时序图,事件的订阅大概可以分成 6 个步骤,下面来一一分析。

方法getDefault()

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

getDefault() 方法就是一个“懒汉”的单例模式,目的就是让我们能在全局对 EventBus 的引用进行使用。值得关注的是,这个懒汉的单例模式实现并不会有多线程的安全问题。因为对于 defaultInstance 的定义是 volatile 的。

static volatile EventBus defaultInstance;

接下来继续看看构造方法。

构造方法EventBus()

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

构造方法使用了常见的 Builder 模式对 EventBus 中的各个属性进行了初始化。这里使用的是默认配置。一般情况下,我们也都是使用 getDefault() 及其默认配置来获取实例的。我们也可以通过配置 EventBusBuilder 来 build 出一个自己的实例,但是要注意的是,后面的注册、注销以及发送事件都要基于此实例来进行,否则就会发生事件错乱发错的问题。

方法register()
如果不看方法的实现,根据经验判断,我想当 register 的发生,应该是将订阅者中用于接收事件的方法与该事件关联起来。那是不是这样呢?

public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        // 1.通过订阅者类找到其订阅方法
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
           // 2. 然后进行逐个订阅
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

首行来看看找订阅方法。这里封装了一个专门的类 SubscriberMethodFinder,并且通过其方法 findSubscriberMethods() 来进行查找,这里就不贴 findSubscriberMethods() 的代码,而是看看其内部实际用于寻找订阅方法的 findUsingReflection()。

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
           ......
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            ......
        }
        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)) {
                    ......
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                ......
            }
        }
    }

总结一下,该方法主要就是寻找订阅者类中的公有方法,且其参数唯一的以及含有注解声明@Subscribe 的方法。就是我们在写代码时所定义的订阅者方法了。找到订阅者方法后,会将其 method(方法的反射类 Method) 、event、thread mode 以及优先级等封装成一个 SubscribeMethod 然后添加到 FindState 中。

这个 FindState 是 SubscriberMethodFinder 的一个内部类。其用了大小只有 4 的 FIND_STATE_POOL 来进行管理,这样避免了 FindState 对象的重复创建。

最后在 find 中会将所找到订阅者方法添加到 “METHOD_CACHE” 中,这是一个 ConcurrentHashMap 的结构。

Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();

方法subscribe()

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            ......
            }
        }

        // 按优先级进行插入
        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) {
                .....
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

subscribe() 方法完成事件与 subscribe 、 subscribeMethod 的关联,具体怎么关联的呢,请看图。
图片描述

图片描述

这里分别用了 2 个 HashMap 来描述。subscriptionsByEventType 记录了一个事件应该调用哪个订阅者的订阅方法来处理。而 typesBySubscriber 记录了订阅者订阅了哪些事件。

至此,订阅者的注册完成之后,也就相当于是 EventBus 的初始化完成了,那么接下来就可以愉快发送事件了。

3.2.2 事件发送

图片描述

事件的发送看起来好像也比较简单。

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) {
               ......
            }
            try {
               // 在发送状态下,通过遍历事件队列逐个发送事件
                while (!eventQueue.isEmpty()) {
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

post() 方法的主要过程都写在代码注释里了。这里主要关注下 currentPostingThreadState,它的定义如下:

private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

而 PostingThreadState 的定义如下。

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

这里用了 ThreadLocal 来保存 PostingThreadState。ThreadLocal 的主要作用是使得所定义的资源是线程私有的。那么,也就是说,对于每一个发送事件的线程其都有一个唯一的 PostingThreadState 来记录事件发送的队列以及状态。

下图是 ThreadLocal 在 Thread 中的数据结构描述,而这里的 PostingThreadState 就是下图中的 Value。
图片描述

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

postSingleEvent 所做的事情主要就是根据要发送的事情收集事件,然后逐个发送。收集的什么事情呢,很简单,就是收集它的父类事件。也就是说,当我们发送一个事件时,它的所有父类事件也同时会被发送,这里的父类还包括了 Object 在内。所以,这里需要开发者们非常注意了:

事件是具有向上传递性质的

接下来的 postSingleEventForEventType 就是从 subscriptionsByEventType 找出事件所订阅的订阅者以及订阅者方法,即 CopyOnWriteArrayList。
然后再通过方法 postToSubscription() 将事件逐个逐个向订阅者进行发送。在 postToSubscription() 方法中会根据不同的 ThreadMode 来决定不同的线程调度策略,具体在下面讲。而不管采用何种策略,最终都将会通过invokeSubscriber() 进行方法的反射调用来进行订阅方法的调用。

void invokeSubscriber(Subscription subscription, Object event) {
       ......
       subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
       ......
    }

至此,事件的发送就完成了。很简单,其真实的面目就是一个方法的反射调用。而对于事件的发送,这里还应该关注一下线程的调度策略。

3.2.3 线程调度策略。

上面说到线程的调度策略在 postToSubscription() 方法中,那么就来看一看这个方法。

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

针对每个不同的策略,下面来简单看一看。
POSTING
发送者线程直接发送,也是 ThreadMode 的默认值。
MAIN
如果发送者是主线程,则直接发送。如果不是则交给 mainThreadPoster 来发送。mainThreadPoster 是 HandlerPoster 类型,该类继承了 Handler 并实现了 Poster 接口,其实例是由 AndroidHandlerMainThreadSupport 所创建的。AndroidHandlerMainThreadSupport 包含了主线程的 Looper ,而 HandlerPoster 包含了一个链表结构的队列 PendingPostQueue,事件也将插入到 PendingPostQueue 中。每一个事件都会以一个空 Message 发送到主线程的消息队列,消息处理完再取出下一个事件,同样以 Message 的形式来执行,如此反复执行。直到队列为空。
MAIN_ORDERED
一般来说也是通过 mainThreadPoster 来发送,异常情况下才通过发送者线程来发送。从代码侧来看,它主要就是属于 MAIN 策略的第二种情况。
BACKGROUND
如果当前为主线程,则将其投递到 backgroundPoster,否则直接发送。这里的 backgroundPoster 就是一个子线程。
ASYNC
异步模式下,最终就是通过 ExecutorService ,也即线程池来发送的。asyncPoster 即 AsyncPoster,其关于线程调度的关键代码为:

eventBus.getExecutorService().execute(this);

3.2.4 注销订阅者

图片描述

注销就比较简单了,如下代码,主要就是从 typesBySubscriber 这个 map 中将订阅者移除掉,并且解决订阅者和事件的关联。

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

四、总结

从整个分析过程来看,EventBus 是一个比较简单的框架,其涉及到的核心知识是 ThreadLocal 以及方法的反射调用,而基于此为我们封装了一套完整的事件 分发-传递-响应 机制,当然也是一个非常优秀的框架。总结一下,其主要的特点:

  1. 事件的定义是由用户自己来定义的,只要是 POJO 就可以。且需要注意的是,事件具有向上传递的特性,即发送一个事件会连同它的父类事件一起发送。
  2. 关于 ThreadMode,默认则发送者线程发送,并且是同步的。对于主线程则通过主线程的 MainLooper 来实现,异步事件则由线程池来实现。
  3. EventBus 的实例可以通过 getDefault() 的单例来获取,也可以通过 EventBusBuilder 的 builder() 方法来获取,但要注意它们不是同一个 EventBus 的实例,也不能互相发送事件。
打开App,阅读手记
0人推荐
发表评论
随时随地看视频慕课网APP