EventBus的使用与深入学习

注意：以下分析都是基于EventBus 3.0x

转载请注明出处：http://blog.csdn.net/evan_man/article/details/51328628

简单介绍

    EventBus是一个用于简化Andorid、Fragment、Threads、Service之间信息传递的一个发布/订阅事件集。

    传统的Android组件之间的通信方式有：Activity之间使用Intent；Service向Activity发送broadcast；Fragment和Activity之间相互持有对方的引用（随后可以调用对方的相关方法进行事件传递）。传统的事件传递的问题在于：通信方式没有实现解耦，是硬编码在组件中的。组件一旦发生修改，对应的通信方式就需要跟着修改。其实不管什么场景下，我们最好能够使得自己编写的代码最大限度的解耦，这是一个很好的习惯，避免无用功，提高代码利用率。

    使用EventBus的建议：

• 并不建议将应用中所有的事件都通过EventBus进行发送，尤其对于一对一的组件之间通信，建议不要使用EventBus。EventBus的使用场景更像是一种广播，当我们向EventBus发送一个事件，则该事件将会传递给多个该事件的订阅者，比如Service向Activities发送事件。跟LoacalBroadCast有点近似
• 在Activity和Fragment中使用EventBus时，要注意在组件的生命周期开始时registered EventBus，在生命周期结束时unregistered EventBus。否则容易导致OOM；

    使用EventBus的好处在于：

• 简化组件之间的通信方式
• 让业务代码更加简洁（但是需要配合相应注解进行使用）
• 可以指定事件处理方法的执行线程，和订阅者的优先级（跟广播类似）
• 足够的稳定，已经被很多Android应用使用，你绝对不是第一个吃螃蟹的人
• EventBus实现了解耦，事件的创建和分发由EventBus管理，工作在一个单独的线程。EventBus的工作原理如下图：

基本使用

一、引入依赖

    compile 'org.greenrobot:eventbus:3.0.0'
    provided 'org.glassfish:javax.annotation:10.0-b28' //解决获取不到@Subscribe注解的问题

二、定义事件

public class IntentServiceResult { 
    int mResult;
    String mResultValue;
    IntentServiceResult(int resultCode, String resultValue) {
        mResult = resultCode;
        mResultValue = resultValue;
    }
    public int getResult() {   return mResult;  } 
    public String getResultValue() {  return mResultValue; }
}

三、注册EventBus

public class MainActivity extends AppCompatActivity {
    @Override  protected void onPause() { 
        super.onPause();
        EventBus.getDefault().unregister(this);  //注：为了后面分析的方便我们对进行注册的对象取名订阅者，如这里的MainActivity.this对象
    }
    @Override  protected void onResume() { 
        super.onResume();
        EventBus.getDefault().register(this);
    }
}

四、发布事件

EventBus.getDefault().post(new IntentServiceResult(24, "done!!"));

五、创建事件处理方法

public class MainActivity extends AppCompatActivity {
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void doThis(IntentServiceResult intentServiceResult) {
       Toast.makeText(this, intentServiceResult.getResultValue(), Toast.LENGTH_SHORT).show();
    }
}

此处的threadMode = ThreadMode.MAIN表明下面的事件处理方法在 ThreadMode.MAIN线程中执行，默认会在EventBus的工作线程中执行（发送post事件方法所在的线程）。

ThreadMode.POSTING：在和发送事件相同的线程中执行。默认的线程模式

ThreadMode.MAIN：Android的UI线程中执行。

ThreadMode.BACKGROUND：交给EventBus的一条幕后线程去执行，注意EventBus中只有一个这样的幕后线程，所以的异步方法会在这条线程中顺序执行。要求事件处理方法不要耗时太长！

ThreadMode.ASYNC：在一个单独的线程中执行，总是和发送事件的线程以及UI线程相隔离。将每个这样的事件处理方法扔到一个线程池申请一条线程进行处理。对于网络请求等可以使用这种模式！

源码学习

学习之前问问自己目的是什么，这次学习我们只是想了解以下内容

• EventBus内部存储有哪些域，我们通过getDefault方法获取到的是不是它的一个单例？
• EventBus的unregister和register方法内部是怎样的业务逻辑。是简单的将该对象添加一个集合，然后像Retrofit那样为每个使用了@Susbcribe标注的Method创建一个ServiceMethod？
• EventBus的post方法内部的业务逻辑、是去遍历调用注册了该事件的方法来处理该事件？如何快速的找到注册了该事件的方法（Map）？
• 使用了@Subscribe(threadMode = ThreadMode.MAIN)标注的方法为何会在指定的线程中执行？

EventBus.class

Fields：

/*****下面的数据在EventBus自身构造器中被创建*****/
private final Map, CopyOnWriteArrayList> subscriptionsByEventType; 
//以事件类型为key，该事件对应的Subscription集合为value；此处使用CopyOnWrite的好处在于它是线程安全的集合，同一时间只有一个线程可以修改该集合的数据！
private final Map>> typesBySubscriber; 
//以注册EventBus的对象（该对象会接收EventBus发来的事件）为key，该对象接收的事件类型为Value
private final Map, Object> stickyEvents;
//sticky在@Subscribe标注时设置(sticky=true), sticky默认是false；直译过来是粘性事件、说人话那就是该类事件会一直被EventBus所保存，除非用户手动删除！同时从Map, Object>可以看出任何类型的事件只会保存一个对应的实例！
private final HandlerPoster mainThreadPoster;        
//对应ThreadMode.MAIN模式，是一个继承Handler的类
private final BackgroundPoster backgroundPoster; 
//对应ThreadMode.BACKGROUND模式，是一个实现了Runnable方法的类
private final AsyncPoster asyncPoster;                 
//对应ThreadMode.ASYNC模式，是一个实现了Runnable方法的类

/*****下面的数据都是来自EventBusBuilder*****/
private final int indexCount;
//一般情况为0，是EventBuilder.subscriberInfoIndexes.size()的值
private final SubscriberMethodFinder subscriberMethodFinder; 
//订阅方法查找器负责对目标对象中使用了@Subscribe进行标注的方法进行解析得到一个SubscriberMethod对象
private final boolean logSubscriberExceptions;
//一般情况为true
private final boolean logNoSubscriberMessages;
//一般情况为true
private final boolean sendSubscriberExceptionEvent;
//一般情况为true
private final boolean sendNoSubscriberEvent;
//一般情况为true
private final boolean throwSubscriberException; 
//一般情况为false
private final boolean eventInheritance;
//一般情况为true，事件是否具有传递性的标志位
private final ExecutorService executorService;
//执行器，对应一个Executors.newCachedThreadPool()线程池

/*****下面的对象创建时初始化或者类加载时初始化*****/
static volatile EventBus defaultInstance; 
//单例
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder(); 
//创建EventBus对象的Builder
private static final Map, List>> eventTypesCache = new HashMap<>(); 
//以事件类型为key，其对应的所以父类、实现的所有接口及接口父类为value
private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override  protected PostingThreadState initialValue() { return new PostingThreadState(); } 
};
//当前线程的PostingThreadState对象，之后通过get方法获取该对象

接着我们看看使用getDefault方法得到的EventBus对象

getDefault()@EventBus.class

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

一个很经典的单例模式，调用EventBus的构造器创建EventBus对象；

EventBus()@EventBus.class

public EventBus() {
        this(DEFAULT_BUILDER);
}
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; //一般情况为0
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        //一般情况参数为null、false、false；该对象我们后面会介绍
        logSubscriberExceptions = builder.logSubscriberExceptions; //一般情况为true
        logNoSubscriberMessages = builder.logNoSubscriberMessages; //一般情况为true
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent; //一般情况为true
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;//一般情况为true
        throwSubscriberException = builder.throwSubscriberException; //一般情况为false
        eventInheritance = builder.eventInheritance; //一般情况为true
        executorService = builder.executorService; //一个newCachedThreadPool()
}

EventBusBuilder.class

Fields：

private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();  
List subscriberInfoIndexes;
boolean strictMethodVerification;
boolean ignoreGeneratedIndex;
boolean logSubscriberExceptions = true;
boolean logNoSubscriberMessages = true;
boolean sendSubscriberExceptionEvent = true;
boolean sendNoSubscriberEvent = true;
boolean throwSubscriberException;
boolean eventInheritance = true;
ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
//总结：eventInheritance、logXX和sendXX全为true；其它全为false；

到此为止我们分析了调用getDefault方法得到的EventBus对象；

该对象存储有如下两个集合

Map, CopyOnWriteArrayList> subscriptionsByEventType; 

• 以事件类型为键，每个事件对应一个Subscription对象的集合。EventBus一旦收到一个事件就会遍历它对应的Subscription集合，将该事件推送给Subscription处理。对于Subscription对象的如何构建和使用后文将会给出。

Map>> typesBySubscriber; 

• 以事件订阅者为键（事件订阅者就是register方法的参数），每个订阅者对应一组它能接收的事件类型集合。一旦订阅者和EventBus解除注册，即调用unregister方法时，EventBus就会取出订阅者对应的所有事件类型，去subscriptionsByEventType中移除该事件对应的Subscription对象集合中的和订阅者关联的Subscription。

该对象存储有如下四个执行器

ExecutorService executorService = Executors.newCachedThreadPool();  

• 是一个线程池，ThreadPoolExecutor(0.Integer.MAX_VALUE,....)

HandlerPoster mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);

• 对应ThreadMode.MAIN模式，是一个继承Handler的类；事件的推送在其HandlerMessage方法中执行

private final BackgroundPoster backgroundPoster;

• 对应ThreadMode.BACKGROUND模式，是一个实现了Runnable方法的类；事件的推送就是将自己扔给executorService，如果当前对象已经在执行了，则只是将事件放入到BackgroundPoster中的一个队列中；否则将自己交给线程池执行其run方法。BackgroundPoster对象的run方法会一直遍历这个队列，直到队列没有数据则退出run方法。

private final AsyncPoster asyncPoster;   

• 对应ThreadMode.ASYNC模式，是一个实现了Runnable方法的类；相对于BackgroundPoster这里一旦有事件需要分发则立即将自己扔给线程池，而不是直接将事件扔给队列就完了。

本节后面还会对上述这些执行器进行详细的说明。下面我们先来分析下EventBus的register方法。

register()@EventBus.class

public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass); //note1
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) { //note2
                subscribe(subscriber, subscriberMethod); 
            }
        }
}

1、从subscriberMethodFinder中获取subscriberClass (注意这里是Class对象不是Obejct对象) 对应的使用了@Subscribe标注的方法集合；大体流程：从缓存区中尝试获取，获取不到再利用FindSubscriber中的FindState去解析subscriberclass对象。SubscriberMethodFinder.findSubscriberMethods方法参考后面的SubscriberMethodFinder.class部分的介绍。实在憋不住就先跳到那里看看如何实现-->

2、遍历集合List中的每个元素，调用subscribe方法处理。SubscriberMethod是对使用了@Subscribe标注的方法的解析，该对象包含有方法(Method)、方法参数类型(Type)、线程模式(ThreadMode)、订阅的优先级。SubscriberMethod与Retrofit为每个采用了标注的方法创建ServiceMethod对象的做法类似。

下面我们看看subscribe方法底层实现。

subscribe()@EventBus.class

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType; //note1
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod); //note2

        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType); //note3
        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(); //note4
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        List> subscribedEvents = typesBySubscriber.get(subscriber); //note5
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        if (subscriberMethod.sticky) { //note6
            if (eventInheritance) {
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, Object> entry : entries) {
                    Class candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) { //从stickyEvents获取对应的事件交给当前事件订阅者处理
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent); //该方法底层还是会执行postToSubscription方法
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
}

1、获取方法参数类型；注意：使用@Subscribe标注的方法有且仅有一个参数

2、利用订阅者对象及其事件处理方法构建一个Subscription对象，该对象存储有Object、SubscriberMethod对象，在本节的最后也贴上了Subscription.class的源码

3、从subscriptionsByEventType集合中获取当前事件对应的Subscription对象集合; 如果得到的集合为空则创建一个这样的集合，并将刚创建的Subscription对象添加进subscriptionsByEventType集合中；如果得到的集合不为空且刚创建的Subscription对象已经存在该集合中则抛出异常，即同一个对象不能注册两次！

4、将第二步创建的Subscription对象按照优先级存入Subscription对象集合中，该集合中的元素都是按照优先级从高到低存放.

5、以subscriber对象为键，从typesBySubscriber获取该对象对应的接收事件类型集合，没有则创建一个这样的集合，然后当前事件类型添加到该集合中，最后将整个集合添加进typesBySubscriber集合中；有则直接添加到接收事件类型集合中；

6、该值默认为false，除非在注册事件方法时使用了如下的标注@Subscribe(sticky = true)；那么就会执行到这里。stickyEvent也是EventBus3.0的一大特点，该类事件一旦发送给EventBus，那么EventBus就会将它存入Map, Object> stickyEvents集合中，key事件类型，value事件实例；每个类型事件对应最新的实例。当订阅对象的某个事件处理方法使用了@Subscribe(sticky = true)标注，EventBus一旦对订阅者完成了注册任务之后，立即将stickyEvents集合中的匹配事件发送给该事件处理进行处理！具体实现就是这里！stickyEvents配套使用的向EventBus发送事件的方法为postSticky,具体内容如下：

public void postSticky(Object event) {
        synchronized (stickyEvents) {   stickyEvents.put(event.getClass(), event); } 
        post(event);
}

同时将stickyEvents中某个类型的事件手动删除的方法为：

public  T removeStickyEvent(Class eventType) {
        synchronized (stickyEvents) {
            return eventType.cast(stickyEvents.remove(eventType));
        }
}

接着看看unregister方法内部逻辑

unregister()@EventBus.class

public synchronized void unregister(Object subscriber) {
        List> subscribedTypes = typesBySubscriber.get(subscriber);//note1
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType); //
            }
            typesBySubscriber.remove(subscriber); //note3
        } else {
            Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
}

1、从typesBySubscriber获取该对象接收的事件类型集合；

2、对得到的接收事件类型集合中的每个事件类型调用unsubscribeByEventType进行处理；跟着我们就分析该方法

3、该对象从typesBySubscriber集合中移除；

unsubscribeByEventType()@EventBus.class

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

1、从subscriptionsByEventType集合中获取该事件类型对应的Subscription集合

2、如果集合中的元素——Subscription的subscriber域等于目标subscriber，则将该Subscription从subscriptionsByEventType集合中移除出去；

分析完了register和unregister方法我们接着分析EventBus的最后一个方法——post方法！

post()@EventBus.class

public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get(); //note1
        List