一、简单使用

依赖

implementation 'org.greenrobot:eventbus:3.2.0'

Demo

public class MainActivity extends AppCompatActivity {

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

        // 注册订阅者
        EventBus.getDefault().register(this);

        // 测试按钮
        findViewById(R.id.tv).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 事件发布者(Publisher):用于通知 Subscriber 有事件发生。可以在任意线程任 意位置发送事件。
                EventBus.getDefault().post(new ToastEvent("123"));
            }
        });

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 必须要回收 否则会内存泄漏
        EventBus.getDefault().unregister(this);
    }


    /**
     * 事件订阅者(Subscriber):接收特定的事件。
     *
     * @param event 传递的事件
     */
    @Subscribe
    public void receiveToast(ToastEvent event) {
        Toast.makeText(MainActivity.this, "测试点击事件   --> " + event.getMsg(), Toast.LENGTH_SHORT).show();
    }


    /**
     * 事件(Event):可以是任意类型的对象。通过事件的发布者将事件进行传递。
     */
    public static class ToastEvent {
        private String msg;

        public ToastEvent(String msg) {
            this.msg = msg;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }
    }

}

二、EventBus简介

EventBus是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。

作为一个消息总线主要有三个组成部分:

事件(Event):可以是任意类型的对象。通过事件的发布者将事件进行传递。
事件订阅者(Subscriber):接收特定的事件。
事件发布者(Publisher):用于通知 Subscriber 有事件发生。可以在任意线程任意位置发送事件。

上图解释了整个EventBus的大概工作流程:事件的发布者(Publisher)将事件 (Event)通过post()方法发送。EventBus内部进行处理，找到订阅了该事件 (Event)的事件订阅者(Subscriber)。然后该事件的订阅者(Subscriber)通过 onEvent()方法接收事件进行相关处理(关于onEvent()在EventBus 3.0中有改动，下面详细说明)。

三、EventBus的进阶使用

1.线程模式ThreadMode

当你接收的的事件后，如果处于非UI线程，你要更新UI怎么办?如果处于UI线程，
你要进行耗时操作，怎么办?等等其他情况，通过ThreadMode统统帮你解决。

    @Subscribe(threadMode = ThreadMode.MainThread)
    public void onNewsEvent(NewsEvent event) {
        String message = event.getMessage();
        mTv_message.setText(message);
    }

PostThread:
事件的处理在和事件的发送在相同的进程，所以事件处理时间不应太长，不然影响事件的发送线程。
MainThread:
事件的处理会在UI线程中执行。事件处理时间不能太长，这个不用说的，长了会ANR的。
BackgroundThread:
如果事件是在UI线程中发布出来的，那么事件处理就会在子线程中运行，如果事件本来就是子线程中发布出来的，那么事件处理直接在该子线程中执行。所有待处理事件会被加到一个队列中，由对应线程依次处理这些事件，如果某个事件处理时间太长，会阻塞后面的事件的派发或处理。
Async:
事件处理会在单独的线程中执行，主要用于在后台线程中执行耗时操作，每个事件会开启一个线程。

2.priority事件优先级

事件的优先级类似广播的优先级，优先级越高优先获得消息。用法展示:

    @Subscribe(priority = 100,threadMode = ThreadMode.MAIN)
    public void onToastEvent(ToastEvent event) {
         Toast.makeText(MainActivity.this, event.getMsg(), Toast.LENGTH_SHORT).show();
    }

当多个订阅者(Subscriber)对同一种事件类型进行订阅时，即对应的事件处理方法中接收的事件类型一致，则优先级高(priority 设置的值越大)，则会先接收事件进行处理;优先级低(priority 设置的值越小)，则会后接收事件进行处理。

除此之外，EventBus也可以终止对事件继续传递的功能。用法展示:

    @Subscribe(priority = 100, threadMode = ThreadMode.MAIN)
    public void onToastEvent(ToastEvent event) {
        Toast.makeText(MainActivity.this, event.getMsg(), Toast.LENGTH_SHORT).show();
        // 取消后续的事件分发
        EventBus.getDefault().cancelEventDelivery(event);
    }

这样其他优先级比100低，并且订阅了该事件的订阅者就会接收不到该事件。

3.EventBus黏性事件

EventBus除了普通事件也支持粘性事件。可以理解成:订阅在发布事件之后，但同样可以收到事件。订阅/解除订阅和普通事件一样，但是处理订阅的方法有所不同，需要注解中添加sticky = true。用法展示:

    @Subscribe(priority = 100, threadMode = ThreadMode.MAIN, sticky = true)
    public void onToastEvent(ToastEvent event) {
        Toast.makeText(MainActivity.this, event.getMsg(), Toast.LENGTH_SHORT).show();
        // 取消后续的事件分发
        EventBus.getDefault().cancelEventDelivery(event);
    }

这样，假设一个ToastEvent 的事件已经发布，此时还没有注册订阅。当设置了 sticky = true，在ToastEvent 的事件发布后，进行注册。依然能够接收到之前发布的事件。

不过这个时候，发布事件的方式就改变了。

EventBus.getDefault().postSticky(new ToastEvent("Toast,发个提示， 祝大家新年快乐!"));

我们如果不再需要该粘性事件我们可以移除

 EventBus.getDefault().removeStickyEvent(ToastEvent.class);

或者调用移除所有粘性事件

 EventBus.getDefault().removeAllStickyEvents();

四、源码解析

getDefault()

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

通过上述代码可以得知，getDefault()中通过双检查锁(DCL)机制实现了 EventBus的单例机制，获得了一个默认配置的EventBus对象。下面我们继续看 register()方法。

register()

在了解register()之前，我们先要了解一下EventBus中的几个关键的成员变量。方便对下面内容的理解。

/** Map<订阅事件, 订阅该事件的订阅者集合> */
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
/** Map<订阅者, 订阅事件集合> */
private final Map<Object, List<Class<?>>> typesBySubscriber;
/** Map<订阅事件类类型,订阅事件实例对象>. */
private final Map<Class<?>, Object> stickyEvents;

下面看具体的register()中执行的代码。

    public void register(Object subscriber) {
        //订阅者类型
        Class<?> subscriberClass = subscriber.getClass();
        //获取订阅者全部的响应函数信息(即上面的onNewsEvent()之类的方法)
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //循环每一个事件响应函数，执行 subscribe()方法，更新订阅相关信息
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

由此可见，register()第一步获取订阅者的类类型. 第二步,通过 SubscriberMethodFinder类来解析订阅者类,获取所有的响应函数集合. 第三步,遍历订阅函数,执行 subscribe()方法，更新订阅相关信息。关于 subscriberMethodFinder这里就不介绍了。先跟着线索，继续看subscribe()方法。 subscribe 函数分三步。

    // Must be called in synchronized block
    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 {
            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);

        // 第三步
        //该事件是stick=true。
        if (subscriberMethod.sticky) {
            //响应订阅事件的父类事件
            if (eventInheritance) {
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
                //循环获得每个stickyEvent事件
                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);
            }
        }
    }

由此可见，第一步:通过subscriptionsByEventType得到该事件类型所有订阅者信息队列，根据优先级将当前订阅者信息插入到订阅者队列 subscriptionsByEventType中;
第二步:在typesBySubscriber中得到当前订阅者订阅的所有事件队列，将此事件保存到队列typesBySubscriber中，用于后续取消订阅;
第三步:检查这个事件是否是 Sticky 事件，如果是则从stickyEvents事件保存队列中取出该事件类型最后一个事件发送给当前订阅者。
到此，便完成了订阅功能。下面是订阅的具体流程图:

unregister()

    public synchronized void unregister(Object subscriber) {
        // 获取该订阅者所有的订阅事件类类型集合.
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class<?> eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            // 从typesBySubscriber删除该<订阅者对象,订阅事件类类型集合>
            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--;
                }
            }
        }
    }

unregister()方法比较简单，主要完成了subscriptionsByEventType以及
typesBySubscriber两个集合的同步。

post()

    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 {
                // 循环处理当前线程eventQueue中的每一个event对象.
                while (!eventQueue.isEmpty()) {
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                // 处理完知乎重置postingState一些标识信息.
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

post 函数会首先得到当前线程的 post 信息PostingThreadState，其中包含事件队列，将当前事件添加到其事件队列中，然后循环调用 postSingleEvent 函数发布队列中的每个事件。

总结

1、要理解EventBus就要从register，unRegister,post,postSticky方法入手。要理解register实质上是将订阅对象（比如activity）中的每个带有subscriber的方法找出来，最后获得调用的就是这些方法。订阅对象（比如activity）是一组event方法的持有者。

2、后注册的对象中sticky方法能够收到之前的stickyEvent方法的原因是EventBus中维护了stickyEvent的hashMap表，在subsribe注册的时候就遍历其中有没有注册监听stickyEvent如果有就会执行一次回调。

EventBus缺点

1、使用的时候有定义很多event类
2、event在注册的时候会调用反射去遍历注册对象的方法在其中找出带有@subscriber标签的方法，性能不高。
3、需要自己注册和反注册，如果忘了反注册就会导致内存泄漏

事件总线框架：EventBus 实现原理