EventBus是一个Android的事件发布/订阅框架

EventBus流程图.png

三个角色

Event：事件，它可以是任意类型，EventBus会根据事件类型进行全局的通知。
Subscriber：事件订阅者，在EventBus 3.0之前我们必须定义以onEvent开头的那几个方法，分别是onEvent、onEventMainThread、onEventBackgroundThread和onEventAsync，而在3.0之后事件处理的方法名可以随意取，不过需要加上注解@subscribe，并且指定线程模型，默认是POSTING。
Publisher：事件的发布者，可以在任意线程里发布事件。一般情况下，使用EventBus.getDefault()就可以得到一个EventBus对象，然后再调用post(Object)方法即可。

一、EventBus对象创建

EventBus.getDefault()

getDefault()方法实际上就是一个单例模式

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

再看一下构造函数中如何实现的

    public EventBus() {
        this(DEFAULT_BUILDER);
    }
 
    EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
         // event为key，Subscriber为value，发布event时可以通过这个map找到对应的订阅者
        subscriptionsByEventType = new HashMap<>();
        // Subscriber为key，event为value，注册和反注册时会操作这个map 
        typesBySubscriber = new HashMap<>();
        // 存储粘性事件，所谓的黏性事件，就是指发送了该事件之后再订阅者依然能够接收到的事件 
        stickyEvents = new ConcurrentHashMap<>();
     
        mainThreadSupport = builder.getMainThreadSupport();
        // 下面三个poster是用来负责线程调度的 
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        backgroundPoster = new BackgroundPoster(this);
        asyncPoster = new AsyncPoster(this);
        // event 索引
        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;
    }

他的构造函数的public的，他这么设计是因为，Eventbus在我们的app中不仅仅只有一条事件总线，可以有多条，可以在不同的事件总线上发送事件和监听事件

DEFAULT_BUILDER是EventBusBuilder的一个静态对象，是通过Builder模式来创建的

HandlerPoster

final class HandlerPoster extends Handler {
    // 用来发即将执行的post事件的队列
    private final PendingPostQueue queue;
    // handleMessage处理事件队列的最大时间
    private final int maxMillisInsideHandleMessage;
    // handler是否在处理消息
    private boolean handlerActive;

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

BackgroundPoster

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

二、@Subscribe注解


@Documented
@Retention(RetentionPolicy.RUNTIME)// 运行时有效 
@Target({ElementType.METHOD})// 用来描述方法
public @interface Subscribe {
    // 线程模式
    ThreadMode threadMode() default ThreadMode.POSTING;
   // 是否是粘性事件
    boolean sticky() default false;
   // 优先级
    int priority() default 0;
}

1、四种线程模型

EventBus3.0有四种线程模型，分别是：

POSTING：默认，表示事件处理函数的线程跟发布事件的线程在同一个线程。
MAIN：表示事件处理函数的线程在主线程(UI)线程，因此在这里不能进行耗时操作。
BACKGROUND：表示事件处理函数的线程在后台线程，因此不能进行UI操作。如果发布事件的线程是主线程(UI线程)，那么事件处理函数将会开启一个后台线程，如果果发布事件的线程是在后台线程，那么事件处理函数就使用该线程。
ASYNC：表示无论事件发布的线程是哪一个，事件处理函数始终会新建一个子线程运行，同样不能进行UI操作。

2、粘性事件

事件消费者在事件发布之后才注册的也能收到该事件
EventBus会存储所有的粘性事件

三、订阅register

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        // 通过subscriberMethodFinder找到订阅方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
               //完成订阅
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

subscriberMethodFinder.findSubscriberMethods：查找订阅方法

    List findSubscriberMethods(Class subscriberClass) {
        // 从方法缓存中查找
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        // ignoreGeneratedIndex 默认为false
        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 通过 findUsingInfo查找
            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;
        }
    }

    private List findUsingInfo(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            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.moveToSuperclass();
        }
        // 返回查找到的订阅方法
        return getMethodsAndRelease(findState);
    } 

    private List getMethodsAndRelease(FindState findState) {
        List 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;
    }

subscribe(subscriber, subscriberMethod)：完成订阅

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        // Subscription 是subscriber和subscriberMethod两个变量的封装 
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            // 放到hashmap中
            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) {
                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);
            }
        }
    }

发送事件post

    public void post(Object event) {
       //1. 通过ThreadLocal获取PostingThreadState
        PostingThreadState postingState = currentPostingThreadState.get();
        List

EventBus源码解析