EventBus3.0源码解析

前言

EventBus是一个优秀的事件订阅/发布框架，充分解耦了事件的发布者和订阅者，简化了代码。 记得刚来公司，老大让我看的第一个框架就是EventBus， 用了这么久的EventBus，居然没看过源码，实在惭愧。。。虽然网上已经有很多解析EventBus的文章了，还是决定自己写一篇，这样可以有更深层次、印象更深的理解。

EventBus的使用

这篇文章详细讲解了EventBus的三要素、四种线程模型，以及普通事件和粘性事件的订阅和分发，这里不再多说。

EventBus3.0源码解析

通过EventBus的使用可以看到EventBus主要分为两部分，事件的订阅(注册)和分发。

看源码之前先来熟悉几个概念：

• 事件: 可以是任意类型的对象, 包括自定义的事件. 通过EventBus.getDefault().post(event)分发出去, 在订阅方法的参数中接收事件.
• 订阅者: EventBus.getDefault().register(MainActivity.this), MainActivity就是订阅者.
• 订阅方法: 被@Subscribe修饰的方法, SubscriberMethod描述了订阅方法相关信息

    final Method method;//订阅方法
    final ThreadMode threadMode;//线程模型
    final Class eventType;//传递进来的事件的class对象
    final int priority;//订阅方法的优先级
    final boolean sticky;//是否是粘性事件
    String methodString;//方法的名称

• 订阅关系Subscription：关联订阅者和订阅方法

    final Object subscriber;//订阅者
    final SubscriberMethod subscriberMethod;//订阅方法
    volatile boolean active;//是否有效, 初始化为true, unregister时置为false

• 注解Subscribe: 用来标识订阅者的订阅方法

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    //线程模型
    ThreadMode threadMode() default ThreadMode.POSTING;
    //是否是粘性事件,默认false
    boolean sticky() default false;
    //优先级, 影响同一个分发线程中事件分发的顺序
    int priority() default 0;
}

• 线程模型ThreadMode: 决定了事件将在哪一个线程中执行,分以下四种:
  POSTING(默认): 在哪个线程分发事件,就在哪个线程处理事件,不需要切换线程.避免执行耗时操作, 有可能会阻塞主线程.
   适用于那些不需要主线程就能快速完成的简单任务
  MAIN: 在主线程中处理事件, 如果在主线程中分发事件,就直接处理事件, 如果不在主线程中分发事件,就通过Handler post到主线程进行处理. 避免进行耗时操作,阻塞主线程.
   适用于更新UI等必须在主线程处理的事件.
  BACKGROUND:在后台进程中处理事件. 如果不在主线程中分发事件, 就在同一个线程中处理事件. 如果在主线程中分发事件, 就启用唯一的后台进程, 依次执行队列中所有的事件. 避免执行长时间耗时操作, 影响队列中其他事件的处理;
   适用于一般的耗时操作;
  ASYNC: 单独开一个线程处理事件, 独立于主线程和分发事件的线程. 因为并发线程数量有限, 应避免同一时间触发大量长时间耗时操作的异步处理方法. EventBus会使用一个线程池来有效回收空闲的异步处理线程.
   适用于访问网络等长时间耗时操作.

事件注册流程

OK, 基本概念讲清楚了, 下面来看下事件注册的入口EventBus.getDefault().register(this). 一般通过EventBus.getDefault()获取EventBus的实例, 来看下创建及初始化的过程.

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
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) {
        //键: 事件的class对象   值: 所有订阅关系集合CopyOnWriteArrayList
        subscriptionsByEventType = new HashMap<>();
        //键: 订阅者   值: 事件class对象的集合
        typesBySubscriber = new HashMap<>();
        //键:事件class对象   值: 粘性事件
        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;
        //查找缓存订阅方法的工具类
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        //是否继承事件, true的话, 发送子事件时, 也会发送父类事件.默认为true
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

下面来看注册的方法:

public void register(Object subscriber) {
        //获取到订阅者对象
        Class subscriberClass = subscriber.getClass();
        //查找订阅者中所有的订阅方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //在同步代码块中对订阅方法逐一进行订阅
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

SubscriberMethodFinder是查找和缓存订阅方法的工具类, 看下findSubscriberMethods方法:

List findSubscriberMethods(Class subscriberClass) {
        //METHOD_CACHE缓存订阅者和订阅者中所有订阅方法的map
        //键: 订阅者对象, 值: List订阅方法的集合
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
         //直接使用缓存中的订阅方法结合
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //是否忽略注解器EventBusAnnotationProcessor生成的MyEventBusIndex
        if (ignoreGeneratedIndex) {
            //通过反射查找订阅者中的订阅方法集合
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            //在MyEventBusIndex类中查找订阅者的订阅方法集合
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        //搜索完为空,抛异常, 不为空, 放入METHOD_CACHE缓存
        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;
        }
    }

注解器EventBusAnnotationProcessor是什么鬼, 还能自动生成MyEventBusIndex来保存所有订阅者与订阅方法集合, 后面再详细讲解. 先看通过反射查找订阅方法findUsingReflection.

private List findUsingReflection(Class subscriberClass) {
        //内部类FindState, 用来保存和校验订阅方法
        FindState findState = prepareFindState();
        //初始化FindState, 把订阅者class对象传进去
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //查找当前订阅者对象中的订阅方法
            findUsingReflectionInSingleClass(findState);
            //查找父类中的订阅方法, clazz变为父类对象,以此循环查找父类中的订阅方法
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }
private FindState prepareFindState() {
        synchronized (FIND_STATE_POOL) {
            从FindState池中找到不为空的FindState,返回,达到复用的目的
            for (int i = 0; i < POOL_SIZE; i++) {
                FindState state = FIND_STATE_POOL[i];
                if (state != null) {
                    FIND_STATE_POOL[i] = null;
                    return state;
                }
            }
        }
       //池中都为空, new一个FindState
        return new FindState();
    }

再来看如何根据FindState查找所有订阅方法findUsingReflectionInSingleClass.

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 拿到该订阅者的所有方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //方法的修饰符必须是public,不是abstract,不是static
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                //方法必须只有一个参数
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                     //方法被Subscribe注解
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        //检查findstate是否添加了该方法,没有返回true
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //将订阅方法的所有信息保存到findState.subscriberMethods
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

循环保存订阅者及父类中所有订阅方法之后, 返回getMethodsAndRelease(findState)

private List getMethodsAndRelease(FindState findState) {
        //获取到之前保存的findState.subscriberMethods,最终返回
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
       //清空findState的状态
        findState.recycle();
        synchronized (FIND_STATE_POOL) {
            //把findState放到池中空闲的位置, 以复用
            for (int i = 0; i < POOL_SIZE; i++) {
                if (FIND_STATE_POOL[i] == null) {
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }

这是通过反射查找订阅者中订阅方法集合, 通过注解器EventBusAnnotationProcessor生成的MyEventBusIndex查找的方法findUsingInfo也放在后面介绍.
至此, 查找订阅者及父类中所有订阅方法结束了, 再看下逐一订阅的方法subscribe.

 private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取到事件
        Class eventType = subscriberMethod.eventType;
        //创建这种订阅关系
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //从缓存中根据事件class对象获取订阅关系集合
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            //缓存中没有, new一个订阅关系集合,保存
            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);
        //缓存没有, new一个加入缓存
        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);
            }
        }
    }

盗个图总结一下整个注册流程: 图来源

register.png

注册流程看完了, 在看一下取消注册的代码:

public synchronized void unregister(Object subscriber) {
        //根据订阅者获取所有事件对象
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                //删除订阅者中事件是eventType 的订阅方法
                unsubscribeByEventType(subscriber, eventType);
            }
            //typesBySubscriber中删除订阅者相关信息
            typesBySubscriber.remove(subscriber);
        } else {
            Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }
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);
                //是当前要取消注册的订阅者, 就删除该订阅方法, 并把active状态置为false
                if (subscription.subscriber == subscriber) {
                    subscription.active = false;
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

事件分发流程

事件分普通事件和粘性事件, 分发也分两种:
普通事件EventBus.getDefault().post(event);
粘性事件:EventBus.getDefault().postSticky(event);

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

由此可以看出粘性事件就是在分发之前保存到stickyEvents中了, 其他与普通事件相同, 看普通事件如何分发;

public void post(Object event) {
        //当前分发线程的状态
        PostingThreadState postingState = currentPostingThreadState.get();
        //当前分发线程的事件队列
        List