Android EventBus 源码解析

EventBus，由greenrobot组织贡献(该组织还贡献了greenDAO),一个Android事件发布/订阅轻量级框架；

进程内EventBus可以代替Android传统的Intent,Handler,Broadcast或接口函数,在Fragment,Activity,Service线程之间传递数据，执行方法；

github地址  https://github.com/greenrobot/EventBus    点击打开链接

在没有它之前，进程内通信一直都是用的广播来发送接收消息，后来用了后发现真的是太方便了，而且还是轻量级的，最近研究了下它的源码，

学习了下大神牛逼的架构和思维，确实很厉害，为啥我没想到呢。

怎么使用的就不做介绍了，相信大家都会用，下面直接进入正文

先看下源码结构，如图：

代码量其实不是很多，很多类里面就只有一点代码，前面3个文件目录都是一些辅助工具类，不是核心，有空可以去学习下，

这里只解析主干逻辑。

平时我们主要用这几个方法：注册订阅者，注销订阅者，定义订阅方法，post事件，所以就从这几个方面开始解析

首先我们知道EventBus用的是单例模式，整个进程中只会有一个EventBus的实例

    static volatile EventBus defaultInstance;

    /** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

这里加上同步，防止多线程调用getDefault()时出现几个实例

接下来看下定义订阅方法

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void refreshUI(RefreshBagEvent event) {
        
    }

    @Subscribe
    public void loadData(DataChangeEvent event) {

    }

平时就是这么定义的订阅方法，为啥要这么写呢，我们先看下这个注解@Subscribe

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    /**
     * 指定订阅方法所在线程
     * @return
     */
    ThreadMode threadMode() default ThreadMode.POSTING;

    /**
     * 是否开启粘性事件
     * If true, delivers the most recent sticky event (posted with
     * {@link EventBus#postSticky(Object)}) to this subscriber (if event available).
     */
    boolean sticky() default false;

    /**
     * 优先级
     * Subscriber priority to influence the order of event delivery.
     * Within the same delivery thread ({@link ThreadMode}), higher priority subscribers will receive events before
     * others with a lower priority. The default priority is 0. Note: the priority does *NOT* affect the order of
     * delivery among subscribers with different {@link ThreadMode}s! */
    int priority() default 0;

}

这个定义的注解包含了3个方法，都有默认值，订阅方法所在线程、是否开启粘性事件模式、优先级

为啥要定义这么一个注解呢？

问题先放这，后面揭晓，接下来看下注册订阅者方法register()

    /**
     * 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);
        // 加上同步block，可能同时有多处都在注册
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

当前订阅者register传入进来，拿到它的Class对象，根据这个Class对象获取register的订阅方法，看下这些订阅方法如何被获取的

    private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();

    List findSubscriberMethods(Class subscriberClass) {
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            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;
        }
    }

可以看到调用了findUsingReflection()或者findUsingInfo()，ignoreGeneratedIndex默认是false，那么就会直接调用 findUsingReflection()，继续往下看

    private List findUsingInfo(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            // 这里应该是从缓存中获取订阅的方法，不过看源码findState.subscriberInfo永远都是null,所以进不去
            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 {
                // 利用反射获取订阅方法储存在findState里面
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        // 从findState中获取订阅方法
        return getMethodsAndRelease(findState);
    }

    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            // 获取注册类中所有声明的所有方法，不包括继承或实现的
            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、静态的方法
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                // 获取方法中参数
                Class[] parameterTypes = method.getParameterTypes();
                // 如果只有一个参数
                if (parameterTypes.length == 1) {
                    // 获取方法中Subscribe注解
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    // 方法中Subscribe注解不为null
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        // 检查findState是否添加过这个订阅方法
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            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)) {
                // 抛出异常，订阅的方法必须是public，不带static、abstract的
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

findUsingReflectionInSingleClass()反射获取订阅方法，看到这知道为啥要用注解@Subcribe了吧，因为一个类那么多方法，怎么知道哪些方法是订阅方法呢，就是用这个注解作为标识

    private List getMethodsAndRelease(FindState findState) {
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        // 回收findState的数据
        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;
    }

到这里，这个订阅者的方法都以List的形式返回了，接着回到register()

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        // 获取订阅者订阅的方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        // 加上同步block，可能同时有多处都在注册
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

接下来就是开始循环把这些订阅方法一个一个的注册了，看下subscribe()

    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        // 获取事件.class对象
        Class eventType = subscriberMethod.eventType;
        // 创建一个含有订阅者和订阅方法的订阅实体
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        // 根据事件类型获取订阅实体集合，CopyOnWriteArrayList是线程安全的
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            // 如果subscriptionsByEventType还没有事件.class对象eventType相关的订阅实体集合，就new 一个
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            // 如果subscriptionsByEventType有eventType相关的订阅实体集合，且包含newSubscription，抛出异常已经注册过了
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        // 把newSubscription添加到subscriptions集合中，默认优先级的情况下添加到末尾；优先级越大添加越靠前
        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;
            }
        }

        // typesBySubscriber用于判断是否注册过某个订阅者
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        // sticky默认false
        if (subscriberMethod.sticky) {
            // eventInheritance 默认为true
            // 如果eventType代表的类或者接口是candidateEventType代表的类或者接口或者父类父接口，也要post事件
            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);
            }
        }
    }

这个方法还挺长的，解析我都写在代码里面了，逻辑还是挺复杂的

    /**
     * 储存事件及父类父接口Class对象；
     * key：事件Class对象，value：事件及父类父接口Class对象
     */
    private static final Map, List>> eventTypesCache = new HashMap<>();

    /**
     * 储存事件及对应方法；
     * key是事件的Class对象，value是订阅者及订阅的方法集合
     */
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    /**
     * 储存订阅者及事件Class对象；
     * 用于判断订阅者是否注册过
     */
    private final Map>> typesBySubscriber;
    /**
     * 存储粘性事件；
     * 用于postSticky()
     */
    private final Map, Object> stickyEvents;

    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            // 初始化一个PostingThreadState对象
            return new PostingThreadState();
        }
    };

跟EventBus这个类的这几个成员变量有关，这几个集合的作用主要是用来存储，具体什么作用我都解释了，这个订阅方法的核心

把事件和订阅者相关的方法存储在subscriptionsByEventType 里面，因为一个事件可能在很多地方都注册过，最后还有一个粘性事件

sticky的处理，什么是粘性事件，比如这个事件在A页面发送完毕了，一般情况下注册过的地方就会马上接受到这个事件处理掉，

然后打开过注册了这个事件的B页面的时候，是不会再接受到这个事件的，而粘性事件就相反，打开B页面同样会接受到这个事件，

可以看下源码

// sticky默认false
        if (subscriberMethod.sticky) {
            // eventInheritance 默认为true
            // 如果eventType代表的类或者接口是candidateEventType代表的类或者接口或者父类父接口，也要post事件
            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);
            }
        }

    private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)
            // --> Strange corner case, which we don't take care of here.
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }

这里才刚开始注册事件，就调用了postToSubscription()去发布事件，postToSubscription()就是post事件的方法，这个方法后面会讲到，到这里注册就算解析完了，估计客观们都晕了，哈哈，我就用一句话概括下：

注册事件其实就是用一个HashMap   subscriptionsByEventType 把事件和注册了事件相关的类和方法储存起来，方便后面post(事件)使用。

接下来看下post()方法，

    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            // 初始化一个PostingThreadState对象
            return new PostingThreadState();
        }
    };

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