EventBus源码分析

面试有一种技巧据说叫做反客为主，当遇到Activity-Fragment通信，甚至模块化开发时的通信问题等等，可以将TA引导到你擅长的领域中来，比如说用EventBus来解决，(RxBus也可以)这时一般套路都会问你懂不懂EventBus的原理，这时你就可以以下文的姿势这样回(zhuang)答(b)了
(๑•̀ㅂ•́)و✧

简介

今天我们来分析截止到现在的3.0.0最新版本
惯例介绍一下我们今天的主角，EventBus，专门管理Android事件通讯。

//依赖
dependencies {
compile 'org.greenrobot:eventbus:3.0.0'
}

Github示例图

在Android开发中难免会遇到以下场景：

• Activity之间的回调startActivityForResult
• 某个页面刷新后联动其他页面也刷新
• Fragment之间的通信
• more

按笔者之前的尿性就是复杂场景用本地广播做发送与监听，广播大吼一声，我叫你一声你敢答应吗(๑•̀ㅂ•́)و✧，是不是很有代入感，直到后来发现广播的性能与Intent传递数据大小有限制以及相对难以维护后来吃下了EventBus这发安利。
笔者先简单的写个基本用法

需要接收事件的类中注册监听（不局限Activity）
EventBus.getDefault().register(this);
别忘记在销毁时反注册
EventBus.getDefault().unregister(this);
发送事件
EventBus.getDefault().post(Object event);
在需要接收事件的类中随便写个方法，例如

 //别忘了这个注解
 @Subscribe
 public void onEventReceive(String event) {

 }

这个方法只要一个参数就够了，由于我们发送事件的时候EventBus根据类型来做校验，例如post("test")，此时所有注册的类中带有Subscribe注解的方法中只要第一个参数是String类型，那么就会调用这个方法，你问我怎么知道的，我等会再告诉你(^__)

浅析

在EventBus光鲜的外表下我们好像看到了观察者模式的影子，没错，我们来从TA的入口开始EventBus.getDefault().register(this);中挨个的调用顺序

public class 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);
    }
}

一个常见的DCL单例模式+构建者模式，我们再来看看EventBusBuilder的构造器

public class EventBusBuilder {
        //默认的线程池
        private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
        //是否打印出订阅时抛出异常的日志
        boolean logSubscriberExceptions = true;
        //是否打印出没有订阅者异常的日志
        boolean logNoSubscriberMessages = true;
        //当订阅者订阅方法执行抛出异常时 ，是否让EventBus发送一个特定事件
        boolean sendSubscriberExceptionEvent = true;
        //当事件没有订阅者时，是否让EventBus发送一个特定事件
        boolean sendNoSubscriberEvent = true;
        //是否抛出订阅者的异常
        boolean throwSubscriberException;
        //是否允许事件可以有继承
        boolean eventInheritance = true;
        //是否忽视生成的索引
        boolean ignoreGeneratedIndex;
        //是否方法严格校验
        boolean strictMethodVerification;
        //线程池
        ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
        //某些类跳过验证，类似绿色通道
        List> skipMethodVerificationForClasses;
        //订阅者的索引集合
        List subscriberInfoIndexes;

        EventBusBuilder() {
        }
    }

贴心的我又都给你们打上注释了，一下子看不明白没关系，后面我们还会再见面的

 //EventBus的一参构造器
 EventBus(EventBusBuilder builder) {
        //根据消息类型的订阅者们，key对应消息的类型，value对应订阅这个类型消息的订阅者们
        subscriptionsByEventType = new HashMap, CopyOnWriteArrayList>();
        //根据订阅者的类型们，key对应订阅者，value对应在这个订阅者订阅的事件类型们
        typesBySubscriber = new HashMap>>();
        //粘性事件，key对应事件类型，valve对应订阅者
        stickyEvents = new ConcurrentHashMap, Object>();
        //主线程的发送器，本质是Handler
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
        //后台线程的发送器，本质是Runnable
        backgroundPoster = new BackgroundPoster(this);
        //异步线程的发送器，本质是Runnable
        asyncPoster = new AsyncPoster(this);
        //订阅者索引数量
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        //订阅者方法搜寻器
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        //↓接受builder的变量
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

如果看官稍微留意一点注释，相信已经对EventBus有所猜测了，没错，在register方法中EventBus肯定对订阅者进行了不为人知的操作，将订阅者和接受的事件等等统统做了记录，抱着这样的猜测我们来瞧瞧register

  public void register(Object subscriber) {
        //获取class
        Class subscriberClass = subscriber.getClass();
        //搜寻器去寻找订阅者要订阅的的集合
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //同步遍历后一一订阅
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

这里可以这样打个比方，subscriber比作小明，小明想订报纸，他去找EventBus，说我要订报纸，然后EventBus派遣搜寻器小刚去整理你要的类型，一看你原来要订旅游（String），拍照（Integer）和运动（Boolean），然后就去专门的专栏一一订阅，以后这些专栏一更新，EventBus就把报纸送到你的手上。
这里我们来看看subscriberMethodFinder的初始化，初始化就在上文EventBus的构造器中

 SubscriberMethodFinder(List subscriberInfoIndexes, boolean strictMethodVerification,
                           boolean ignoreGeneratedIndex) {
        this.subscriberInfoIndexes = subscriberInfoIndexes;
        this.strictMethodVerification = strictMethodVerification;
        this.ignoreGeneratedIndex = ignoreGeneratedIndex;
    }

将订阅者的索引集合，是否方法严格校验，是否忽视索引3个参数传入，有关索引做这块先卖个关子，先提前剧透一下，今天是小明要订报纸，明天又来个小张，小刚每次拿笔都要记一下再去专栏订阅，小张觉得太累了，于是想了个法子，每次要来订报纸，你们先填张表，填完给我，这样将就省事多了。

深入

接下来我们来看看搜寻器的寻找方法有没有什么猫腻

 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方法

private List findUsingReflection(Class subscriberClass) {
        //保存记录
        FindState findState = prepareFindState();
        //初始化
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //通过反射来获取订阅方法
            findUsingReflectionInSingleClass(findState);
            //移动到父类
            findState.moveToSuperclass();
        }
        //将最后结果返回并回收资源
        return getMethodsAndRelease(findState);
    }

FindState就在SubscriberMethodFinder下作为静态内部类，具体如下

static class FindState {
        //寻找到的订阅方法
        final List subscriberMethods = new ArrayList<>();
        //所有符合事件类型的方法，包含父类的
        //key对应事件类型，value对应方法Method
        final Map anyMethodByEventType = new HashMap<>();
        //订阅者可接受的
        //key对应字符串Method名称+">"+事件类型名称，value对应Method的声明类
        final Map subscriberClassByMethodKey = new HashMap<>();
        //拼接
        final StringBuilder methodKeyBuilder = new StringBuilder(128);
        //订阅者的类型
        Class subscriberClass;
        //记录的当前的类
        Class clazz;
        //是否跳过父类
        boolean skipSuperClasses;
        //索引
        SubscriberInfo subscriberInfo;

        //初始化
        void initForSubscriber(Class subscriberClass) {
            this.subscriberClass = clazz = subscriberClass;
            skipSuperClasses = false;
            subscriberInfo = null;
        }

        //回收资源
        void recycle() {
            subscriberMethods.clear();
            anyMethodByEventType.clear();
            subscriberClassByMethodKey.clear();
            methodKeyBuilder.setLength(0);
            subscriberClass = null;
            clazz = null;
            skipSuperClasses = false;
            subscriberInfo = null;
        }

        //通过方法和事件类型是否能够添加到队列中
        boolean checkAdd(Method method, Class eventType) {
            Object existing = anyMethodByEventType.put(eventType, method);
            if (existing == null) {
                //集合中之前未添加过这个事件
                return true;
            } else {
                if (existing instanceof Method) {
                    if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                        // Paranoia check
                        //迷之校验，↑原文注释都在吐槽了
                        throw new IllegalStateException();
                    }
                    anyMethodByEventType.put(eventType, this);
                }
                return checkAddWithMethodSignature(method, eventType);
            }
        }

        //通过方法和事件类型是否能够添加到队列中，二次校验
        private boolean checkAddWithMethodSignature(Method method, Class eventType) {
            methodKeyBuilder.setLength(0);
            methodKeyBuilder.append(method.getName());
            methodKeyBuilder.append('>').append(eventType.getName());
            //按照指定格式拼接作为String key
            String methodKey = methodKeyBuilder.toString();
            Class methodClass = method.getDeclaringClass();
            Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
            if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                //集合未添加过 || 添加过并且后续添加的订阅者方法声明类和之前覆盖的值有子父关系或者同属一类
                return true;
            } else {
                //添加过了且没有类关系
                subscriberClassByMethodKey.put(methodKey, methodClassOld);
                return false;
            }
        }

        //移动到父类
        void moveToSuperclass() {
            if (skipSuperClasses) {
                clazz = null;
            } else {
                clazz = clazz.getSuperclass();
                String clazzName = clazz.getName();
                //跳过系统类
                if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") || clazzName.startsWith("android.")) {
                    clazz = null;
                }
            }
        }
    }

理解起来比较鸡肋，没什么营养，我们结合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，并且不能为static，abstract和2个笔者不懂的迷之修饰符_(:з」∠)_
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                //获取方法需要的参数
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    //一个参数
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        //判断是否可以添加
                        if (findState.checkAdd(method, eventType)) {
                            //提取注解的线程修饰mode
                            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)) {
                //严格校验下就要抛出异常
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

仔细一看就明白多了，在findUsingReflection方法中先初始化了一个FindState对象，然后对订阅者类型的父子继承关系以及事件类型的匹配进行层层筛选，将筛选结果作为List返回给上级，筛选过程比较复杂，感兴趣的同学可以参照笔者上面的注释仔细品味。
总结如下：

• 订阅的方法需要@Subscribe修饰，里面可以附带线程模式和和优先级；
• 订阅方法必须为public，不能为abstract和static；
• 允许订阅者之间的继承关系；

其中SubscriberMethod内部存放一些事件的信息，我们一会再提

public class SubscriberMethod {
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;
    /** Used for efficient comparison */
    String methodString;
}

在将结果返回的方法getMethodsAndRelease中，还做了缓存处理

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

好了，万里长征已经进行了一半了，什么！？你和我说才一半
(╯‵□′)╯︵┻━┻。。。坚持一下，马上就革命胜利了
┬─┬ ノ( ' - 'ノ)
我们回到EventBus的register方法，下一步是加锁遍历搜寻器返回的结果，也就是小刚要把小明，小张的订阅表去订阅道指定专栏

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取事件类型
        Class eventType = subscriberMethod.eventType;
        //一重简单的封装
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //从这个事件类型的map中取出订阅者们
        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) {
                //消息允许继承时
                //遍历map
                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);
            }
        }
    }

在subscribe方法中对事件和订阅者的关系都保存在了map中，然后对粘性事件进行了处理。
这里我们又遇到了粘性事件，打个比方，小张订阅了音乐频道的报纸，想在订阅时希望过往的报纸也能看到。其实和四大组件的粘性广播相似，又比如我们开启一个Activity，我们在Activity的onCreate中注册了事件，但是在传递数据时我们的消息已经发出了，而Activity的初始化不是startActivity一下就能开启的，所以我们在Activity中的订阅方法要改一改，将注解改成@Subscribe(sticky = true)，就能接受到粘性事件。
那么EventBus的注册方法我们从头到尾看了一遍，接下来我们来看看分发方法post

public void post(Object event) {
        //获取当前线程的状态
        PostingThreadState postingState = currentPostingThreadState.get();
        //当前线程的消息队列
        List