EventBus的基本使用和源码解析

最近在项目中使用了EventBus(3.0)，觉得非常好用，于是就看了一些关于EventBus源码分析的文章，现在记录下它的基本使用方法和看源码过程中分析的一些问题。EventBus源码地址

11212.gif

EventBus是什么？

EventBus是一个Android事件发布和订阅的框架，通过解耦发布者和订阅者来简化Android事件传递。

EventBus是干什么的？

EventBus-Publish-Subscribe.png

事件传递既可以用于Android四大组件间通讯，也可以用于异步线程和主线程间通讯等。传统的事件传递方式包括：Handler、BroadcastReceiver、Interface回调，而EventBus就是用来传递事件的，相比传统的方式，它代码简洁，使用简单，并将事件发布和订阅充分解耦。

基本使用方法

添加依赖库

//在app下的build.gradle中添加下面的依赖
compile 'org.greenrobot:eventbus:3.0.0'

注册订阅事件

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

    EventBus.getDefault().register(this);
}

取消注册订阅事件

@Override
protected void onDestroy() {
    super.onDestroy();
    EventBus.getDefault().unregister(this);
}

发布事件

EventBus.getDefault().post(Object obj);

订阅事件

@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(Object obj) {
}

看吧，使用起来还是挺简单的，订阅者真正需要处理逻辑的就是在有注解@subscribe的方法onEvent(Object obj)中去按照我们自己的需求去处理，当然这里方法名不一定是onEvent了，我是受2.4版本影响，习惯了把方法名写成onEvent，在3.0版本中可以随意写，但是参数的class类型必须要跟发布者post的参数的class类型一致。

使用场景

比如有一个列表页面，每个item上都有评论数，点赞数和点赞状态，点进去到详情页，用户可以进行一些操作，评论，点赞，这时候详细页的评论数点赞数和点赞状态我们可以立即更新，但是当我们回到列表页面的时候，也需要更新UI啊，之前也说了，传统的事件传递方式有Handler，BroadcastReceiver，以及Interface回调等，如果不使用EventBus的话，我会考虑使用广播的方式或者用startActivityForResult来打开详细页，等到从详细页返回到列表页时，将操作后的对象传递回来，然后在onActivityResult方法中去处理更新UI。但是这种方法的弊端在于只有在返回到上一个界面时才会将事件传递回来，不能达到立即更新的目的。

线程模式

上面说过，只有使用注解@Subscribe(threadMode = ThreadMode.MAIN)标明的方法才是订阅者需要处理逻辑的地方。那这个threadMode是什么呢？它其实是指定订阅者处理事件的线程，EventBus总共有四种线程模式，分别是：

• ThreadMode.MAIN：表示无论事件是在哪个线程发布出来的，该事件订阅方法onEvent都会在UI线程中执行，这个在Android中是非常有用的，因为在Android中只能在UI线程中更新UI，所有在此模式下的方法是不能执行耗时操作的。

• ThreadMode.POSTING：表示事件在哪个线程中发布出来的，事件订阅函数onEvent就会在这个线程中运行，也就是说发布事件和接收事件在同一个线程。使用这个方法时，在onEvent方法中不能执行耗时操作，如果执行耗时操作容易导致事件分发延迟。

• ThreadMode.BACKGROUND：表示如果事件在UI线程中发布出来的，那么订阅函数onEvent就会在子线程中运行，如果事件本来就是在子线程中发布出来的，那么订阅函数直接在该子线程中执行。

• ThreadMode.ASYNC：使用这个模式的订阅函数，那么无论事件在哪个线程发布，都会创建新的子线程来执行订阅函数。

ASYNC相比前三者不同的地方是可以处理耗时的操作，其采用了线程池，且是一个异步执行的过程，即事件的订阅者可以立即得到执行。虽然BACKGROUND也采用了线程池，但它每次只能执行一个任务，就是不会异步执行。所以一般是更新UI的事件，就使用ThreadMode.MAIN，需要请求网络的事件就使用ThreadMode.AYSNC,。

final class BackgroundPoster implements Runnable {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            queue.enqueue(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                eventBus.getExecutorService().execute(this);
            }
        }
    }

    @Override
    public void run() {
        try {
            try {
                while (true) {
                    PendingPost pendingPost = queue.poll(1000);
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

backgroundPoster通过enqueue方法，将当前的订阅者添加至队列PendingPostQueue
中，是否立即执行，则需要判断当前队列是否还有正在执行的任务，若没有的话，则立即执行，若还有执行任务的话，则只进行队列的添加。这样，保证了后台任务永远只会在一个线程执行。

class AsyncPoster implements Runnable {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    AsyncPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        queue.enqueue(pendingPost);
        eventBus.getExecutorService().execute(this);
    }

    @Override
    public void run() {
        PendingPost pendingPost = queue.poll();
        if(pendingPost == null) {
            throw new IllegalStateException("No pending post available");
        }
        eventBus.invokeSubscriber(pendingPost);
    }

}

AsyncPoster是直接通过线程池调用执行，相比BackgroundPoster执行来说，则没有等待的过程。

final class HandlerPoster extends Handler {

    private final PendingPostQueue queue;
    private final int maxMillisInsideHandleMessage;
    private final EventBus eventBus;
    private boolean handlerActive;

    HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        super(looper);
        this.eventBus = eventBus;
        this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
        queue = new PendingPostQueue();
    }

    void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            queue.enqueue(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                if (!sendMessage(obtainMessage())) {
                    throw new EventBusException("Could not send handler message");
                }
            }
        }
    }

    @Override
    public void handleMessage(Message msg) {
        boolean rescheduled = false;
        try {
            long started = SystemClock.uptimeMillis();
            while (true) {
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }
                eventBus.invokeSubscriber(pendingPost);
                long timeInMethod = SystemClock.uptimeMillis() - started;
                if (timeInMethod >= maxMillisInsideHandleMessage) {
                    if (!sendMessage(obtainMessage())) {
                        throw new EventBusException("Could not send handler message");
                    }
                    rescheduled = true;
                    return;
                }
            }
        } finally {
            handlerActive = rescheduled;
        }
    }
}

HandlerPoster是我们再熟悉不过的Handler消息机制了，它会将每个订阅事件传递到UI线程中进行处理。这里就不多说了。

源码分析

EventBus的事件总线

在EventBus中，真正的订阅对象是SubscriberMethod，包含了相应的Method类，以及事件参数类型Class eventType，其他就是线程，优先级，是否Sticky信息。

public class SubscriberMethod {
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;
}

Sticky=true表示等到回到事件订阅的界面时才开始传递消，而不是一post就开始传递，什么时候使用sticy呢？当你希望你的事件不被马上处理的时候。

事件总线，一般都对应着一个集合，这个集合中的对象就是订阅的事件，而EventBus中使用的是：

private final Map, CopyOnWriteArrayList> subscriptionsByEventType;

subscriptionsByEventType = new HashMap<>();

这里的Map集合采用的是一个HashMap集合，map的key对应就是之前SubscriberMethod中的eventType, value则对应着一个线程安全的List，List中存放的是包含订阅对象Object及相应订阅方法SubscriberMethod的Subscription类：

final class Subscription {
    final Object subscriber;
    final SubscriberMethod subscriberMethod;
}

所以，EventBus内部是用了一个线程安全的List集合来维持所有的订阅者，即事件总线集合。而注册订阅和取消注册订阅就是对这个List集合进行增删的过程。

注册订阅和取消注册订阅

/**
 * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
 * are no longer interested in receiving events.
 * 

 * Subscribers have event handling methods that must be annotated by {@link Subscribe}.
 * The {@link Subscribe} annotation also allows configuration like {@link
 * ThreadMode} and priority.
 */
public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

首先EventBus会根据订阅类的Class去这个类中查找处理订阅事件的方法，SubscriberMethodFinder这个类看名字我们就知道它是干什么用的了，等会在细说。下面我们看看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 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> 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).
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, 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);
        }
    }
}

从这个方法我们可以看到每一个eventType 都对应一个CopyOnWriteArrayList，不过这样读源码太不好理解了，结合我Demo中的例子来说，MainActivity中的subscriberMethod就是onEvent(NewsModel newsModel)方法，所以eventType就是NewsModel类，而subscriber就是MainActivity的实例，他俩组合成了一个订阅者Subscription，然后把eventType作为key，订阅了NewsModel这类事件的订阅者的集合作为value存储在一个HashMap中，最后根据优先级priority将newSubscription这个最新的订阅者添加到订阅列表中。也就是说在一个Activity页面类，我们可以有多个SubscriberMethod，就像下面这样：

@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(NewsModel newsModel) {
    newsList.set(clickPosition, newsModel);
    mAdapter.notifyItemChanged(clickPosition);
}

@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void onEvent1(User user) {
    
}

@Subscribe(threadMode = ThreadMode.ASYNC)
public void onEvent2(Person person) {
    
}

取消注册订阅则是将该事件类型的订阅者从事件总线集合中移除：

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

/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
private void unsubscribeByEventType(Object subscriber, Class eventType) {
    List 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的post(Object event)方法，进行事件的发出。紧接着EventBus的总线List中找出订阅了这个event的方法Subscription，然后根据method指定的不同线程信息，将这个方法的调用，放置在相应线程中调用，看看EventBus中的post方法：

/** Posts the given event to the event bus. */
public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List