EventBus3.0 组件通信框架源码学习总结

一、初始化

EventBus的初始化虽然用了单例模式，但是构造方法居然是public修饰符，可能是应对项目中的多线操作。

//单例模式，针对并发情况进行了双层判断
 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) {
        //通过订阅事件的类型来查找订阅者方法的集合。
        //Map, CopyOnWriteArrayList> subscriptionsByEventType
        subscriptionsByEventType = new HashMap<>();
        //通过订阅者来查找所有订阅事件类型的集合
        //Map>> typesBySubscriber;
        typesBySubscriber = new HashMap<>();
        //用于存放指定的粘性事件
        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);
        ....
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
 }

1. subscriptionsByEventType 和 typesBySubscriber 主要用来存放已经找到的订阅者以及订阅方法。
2. stickyEvents 粘性事件使用方法（sticky = true），标注了粘性事件的方法，在注册时会根据情况向订阅方法发送之前已经推送的消息。

@Subscribe(priority = 1,sticky = true,threadMode = ...)
    public void onMainStoreChange(MainStore.MainStoreChangeEvent event){}

一般情况下，EventBus的注册和解绑是在一下两个方法中，处于后台或者未启动的activity收不到消息，但是注释了粘性事件，会在每次界面启动时收到消息。类似 onActivityResult（）功能。

    @Override
    protected void onResume() {
        super.onResume();
        eventBus.register(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        eventBus.unregister(this);
    }

1. mainThreadPoster 、backgroundPoster 、asyncPoster 三种推送者，发送事件时会根据 threadMode 来确定使用哪一种Poster，后面会具体分析。
2. subscriberMethodFinder 这个类就是查找订阅者中所有的订阅方法的类，后面主要分析。
3. EventBusBuilder 这个建造类，将所有需要定义一些参数全部封装在一个类中，值得学习。

二、注册

 public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        //查找
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                //订阅
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

注册方法的代码不多，做了两件事。
1. 查找订阅事件，任务全部交给 subscriberMethodFinder 来处理，而 subscriberMethods 集合保存了所有订阅事件的封装类，只是得到的集合并没有经过排序、分类等处理，只负责找出来。

 public SubscriberMethod(Method method, Class eventType, ThreadMode threadMode, int priority, boolean sticky) {
     //每个属性对应着 @ subscribe（...）注释上的参数
        this.method = method;
        this.threadMode = threadMode;
        //事件类型
        this.eventType = eventType;
        //优先级
        this.priority = priority;
        //是否是粘性事件
        this.sticky = sticky;
    }

//Subscribe 注释器参数和默认值如下。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;

    boolean sticky() default false;

    int priority() default 0;
}

2.订阅事件，将已经得到的订阅事件集合，通过排序、分类等手段赋值给 subscriptionsByEventType 和 typesBySubscriber 这两个集合，并且对粘性事件进行处理。

============

先分析如何查找，下面到了 subscriberMethodFinder 类中的方法了，思路很清晰，就是先从缓存中获取，没有就通过下面的方法查找，最后将找到的结果返回并加入的缓存中，以便下次查找。

List findSubscriberMethods(Class subscriberClass) {
        //先从METHOD_CACHE缓存中取出列表，没有的话就通过对象参数找出对应的订阅方法列表。
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //通过默认的方式实例化EventBus，ignoreGeneratedIndex为false
        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;
        }
    }

这里一些用于判断的参数都是EventBus初始化变量时通过建造类确定的。ignoreGeneratedIndex 默认为false，所以基本走的就是findUsingInfo（）这个方法，接下来看下这个方法具体逻辑。

private List findUsingInfo(Class subscriberClass) {
        //初始化 FindState 对象，利用复用池缓存用过的 FindState 对象，叼
        //FindState 用于检查和保存合格的订阅方法。
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            //这个判断目前肯定是空的，由于缺少组件，只能走findUsingReflectionInSingleClass方法。
            if (findState.subscriberInfo != null) {
            //编译时就已经将所有订阅方法找到，这里只需要获取即可。
               ...
            } else {
             //运行时具体查找逻辑，效率比较低下
                findUsingReflectionInSingleClass(findState);
            }
            //移到父类
            findState.moveToSuperclass();
        }
        //这个方法将findState中的订阅方法集合全部提取出来，并释放findState对象。
        return getMethodsAndRelease(findState);
    }

总体来说这个方法就是循环遍历订阅者和其超类，找出所有的订阅方法，然后将方法封装进SubscriberMethod这个类，最后将所有的 SubscriberMethod 类（对应一个订阅方法）全部添加到 findState.subscriberMethods 集合中。这里分析的findUsingInfo（） 完全等同 findUsingReflection（）方法。

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {

            //通过反射得到类的所有方法（public 类型），为啥不直接使用getMethods（），上面英文有注释（Activity这种庞大的类，用getDeclaredMethods方法效率更快？）
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {

            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            //获取方法类型
            int modifiers = method.getModifiers();

            //只需要public修饰符的方法，MODIFIERS_IGNORE 包含除public以外所有的修饰符
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {

                //得到方法的参数类型
                Class[] parameterTypes = method.getParameterTypes();

                //订阅者的订阅方法只允许拥有一个订阅事件的参数
                if (parameterTypes.length == 1) {

                    // 返回改程序元素上存在的、指定类型的注解，如果该类型注解不存在，则返回null
                    // 判断方法是否为订阅方法
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];

                        //就是过滤掉了超类中的完全相同的订阅事件
                        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)) {
                   ....
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
               ....
            }
        }
    }

上面代码就是一步步过滤掉不符合要求的方法，最后剩下的 method 就是需要订阅的方法。接下来具体看看findState.checkAdd()方法，这个方法中一些逻辑有点难度。

 boolean checkAdd(Method method, Class eventType) {
            // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
            // Usually a subscriber doesn't have methods listening to the same event type.
            //通常情况下不能存在多个同样参数的订阅方法，不过也能收到同样的消息。
            Object existing = anyMethodByEventType.put(eventType, method);
            //existing 为空代表这个订阅者没有相同参数的订阅方法
            if (existing == null) {
                return true;
            } else {
                //这里处理的就是有多个相同参数的订阅方法的情况，将上一个方法用来比对
                if (existing instanceof Method) {
                    if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                        // Paranoia check
                        throw new IllegalStateException();
                    }
                    // Put any non-Method object to "consume" the existing Method
                    anyMethodByEventType.put(eventType, this);
                }
                //方法不同事件相同的Method都会返回true,Method完全一样的只添加一次。
                //从代码上理解，不同方法名但是订阅事件相同的方法都会收到消息，但是超类有相同的方法，只有子类会收到消息。
                return checkAddWithMethodSignature(method, eventType);
            }
        }

anyMethodByEventType集合只是用于排查是否存在相同订阅事件的方法（从子类开始往超类排查）。如果不存在就将这个订阅方法正常返回，如果存在，就需要通过事件的签名来检查（订阅方法名称>订阅事件名称），使用得是二级检查。意思就是同时对之前anyMethodByEventType已经存在的方法和具有相同事件类型的方法进行检查。

可以确定的是如果方法名一样，前者肯定是子类（不可能一个类中有两个相同的方法）。可以看下checkAddWithMethodSignature（）具体逻辑。

        private boolean checkAddWithMethodSignature(Method method, Class eventType) {
            methodKeyBuilder.setLength(0);
            methodKeyBuilder.append(method.getName());
            methodKeyBuilder.append('>').append(eventType.getName());
            String methodKey = methodKeyBuilder.toString();

           // 得到目标属性所在类对应的Class对象
            Class methodClass = method.getDeclaringClass();
            Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);

            //1.如果methodClassOld为空，或者是methodClass的超类，返回true
            //2.如果methodClassOld 不为空，代表两个方法完全一样，根据排查逻辑 methodClassOld 不可能是超类，只有可能是子类。
            //所以，必须返回false，因为methodClassOld的方法已经加到集合中，不需要将它的父类方法再一次加进去。
            //保证了完全相同的方法只执行一次，子类完全可以使用super.xxx()。
            //解释的很牵强....
            if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                // Only add if not already found in a sub class
                return true;
            } else {
                // Revert the put, old class is further down the class hierarchy
                subscriberClassByMethodKey.put(methodKey, methodClassOld);
                return false;
            }
        }

subscriberClassByMethodKey 集合key对应上面所说到的签名，key值相同代表有两个相同的订阅方法。代码注释很详细。所以checkAdd方法仅仅过滤掉子类和超类中完全相同的订阅方法，仅保留子类中的方法。
这样findState.subscriberMethods集合就保存了所有有效的订阅方法啦。

无论是 findUsingInfo 还是 findUsingReflection方法最后都是调用下面的方法返回集合的。

  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) {
                //findstate复用池还有空间就将对象添加进去
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }

========
再回到eventBus的注册方法，这时候subscriberMethods 集合的值就知道怎么来的了。

public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

查找逻辑完了，在看看subscribe（）方法吧，每次订阅方法都要执行一次这个方法。这个循环订阅的过程必须受线程保护的。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;

        //Subscription二次封装了订阅者对象和 subscriberMethod，并且put到 CopyOnWriteArrayList 集合。
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod); 

        //CopyOnWriteArrayList 适用于多线程并发操作，集合中存储的对象是以订阅者（类名.class）划分的
        //每个相同的eventType对应一个CopyOnWriteArrayList 集合
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            //subscriptions 不为null代表有相同订阅事件类型的 Subscription 对象。
            //如果在相同订阅事件类型前提下，订阅对象和订阅方法完全一样，就抛异常。Subscription对象中有具体的 equals（）判断方法
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        //根据注释中的 priority 值大小对相同订阅事件类型的 newSubscription 进行排序，
        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 = true的事件，才会执行下面的方法。
        if (subscriberMethod.sticky) {
            //只有在注册之前调用了postSticky()方法，下面的post才会有效
            if (eventInheritance) {

                //如果class A extends B，A 事件为粘性事件，参数为 A 和 B订阅方法都能能收到 A 对象的消息。
                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 {
                //eventInheritance = false情况，参数为 B 的注释方法是收不到消息的。
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

1.Subscription 是订阅者和订阅方法（SubscriberMethod）的封装对象。

2.这时候 subscriptionsByEventType 集合终于用上了，以事件类型为key、subscriptions集合为value。

3.CopyOnWriteArrayList subscriptions，事件类型相同的Subscription对象都会添加到这个集合。
查看CopyOnWriteArrayList.contains（obj）方法源码，发现用的是obj.equals（obj1）方法来判断的。
Subscription 类中的equals方法（注释很详细）：

@Override
    public boolean equals(Object other) {
        //在EventBus.subscribe方法中用于判断 Subscription 集合中是否已经添加过相同的 Subscription对象
        if (other instanceof Subscription) {
            Subscription otherSubscription = (Subscription) other;
            return subscriber == otherSubscription.subscriber
                    && subscriberMethod.equals(otherSubscription.subscriberMethod);
        } else {
            return false;
        }
    }

4.typesBySubscriber集合也用上了，以订阅对象为key，事件类型（eventType）为value。

5.stickyEvents 粘性事件，每次发送粘性事件否会保存在这个集合中，没发送出去不会被销毁。

subscribe 方法中首先对 subscriptionsByEventType 集合赋值，然后在对 typesBySubscriber 集合赋值，具体逻辑代码写的很详细，最后就是对粘性事件的处理了（发送粘性事件：postSticky() 不是 post()）。

 public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

而checkPostStickyEventToSubscription（）方法就是具体发送消息的逻辑了，这块和post逻辑一起分析。

三、发送消息

postSticky()方法已经贴出来了，逻辑非常简单，下面看看post（）方法。

  public void post(Object event) {
        //currentPostingThreadState 为 ThreadLocal对象，多线程调用时为每个线程单独维护PostingThreadState 对象
        PostingThreadState postingState = currentPostingThreadState.get();
        List