EventBus源码分析

差不多两年没写博客了，最近想着要找工作了，打算复习下一些常用的开源库，也是这篇博客的由来～

EventBus使用非常简单 参考：github
再贴一张官网的图

一、示例代码

示例代码是为了便于理解后面注解处理器生成代码的处理流程

public class TestRunnerActivity extends Activity {

    private EventBus eventBus;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_runtests);
        eventBus = new EventBus();
        eventBus.register(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEventMainThread(TestFinishedEvent event) {

    }

    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onEventBackgroundThread(TestEvent event) {
    }

    public void onDestroy() {
        eventBus.unregister(this);
        super.onDestroy();
    }
}

二、EventBus#register流程

调用register进行订阅 ,参数this代表订阅者

public void register(Object subscriber) {       
        //获取订阅者的class类型
        Class subscriberClass = subscriber.getClass();
        //获取subscriber所有的订阅方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                //对订阅类中的每个订阅方法进行订阅
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

首先调用了findSubscriberMethods获取了当前订阅者类里的所有订阅方法。

List findSubscriberMethods(Class subscriberClass) {
        //如果缓存有，直接返回。 METHOD_CACHE类型是Map, List>
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //ignoreGeneratedIndex默认是false
        if (ignoreGeneratedIndex) {
            //方式1:通过反射获取到所有的订阅方法
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            //方式2:通过注解处理器生成的代码来获取所有的订阅方法
            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 findUsingReflection(Class subscriberClass) {
        //从对象缓存池获取一个FindState，这只是一个工具对象
        FindState findState = prepareFindState();
   			//给findState成员变量subscriberClass 、class赋值为subscriberClass
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
          	//通过反射去找
            findUsingReflectionInSingleClass(findState);
            //继续找父类中的所有方法
            findState.moveToSuperclass();
        }
        //返回找到的List，回收FindState
        return getMethodsAndRelease(findState);
    }

反射的核心逻辑在findUsingReflectionInSingleClass方法,该方法通过反射查找class的所有方法，然后遍历这些方法找到带@Subscribe的方法，然后将查询的结果保存到findState.subscriberMethods中

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            //getDeclaredMethod()获取的是类自身声明的所有方法，包含public、protected和private方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            ...
        }
        //遍历所有方法，找到带Subscribe注解的方法 比如：@Subscribe(threadMode = ThreadMode.MAIN)
        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注解
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        //获取事件类型
                        Class eventType = parameterTypes[0];
                        //检查method&eventType对于的订阅方法是否已经添加过了
                        if (findState.checkAdd(method, eventType)) {
                            //获取方法的线程模式
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //最终将找到的结果 封装到SubscriberMethod里面，然后保存到findState.subscriberMethods中
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } 
            } 
        }
    }

前面的findUsingReflection方法先通过反射找到订阅类里的所有订阅方法，然后保存到findState.subscriberMethods中，接着调用getMethodsAndRelease(findState),将
List< SubscriberMethod>返回，然后回收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;
    }

Ok，现在我们已经通过反射获取到订阅类中的所有订阅方法了，并且将它们封装到List< SubscriberMethod>中了，我们先不管注解处理器获取List< SubscriberMethod>的逻辑，继续看register方法，获取到List< SubscriberMethod>后开始遍历List< SubscriberMethod>，对每个SubscriberMethod调用subscribe

subscribe主要干了两件事

1、将订阅方法和订阅者封装到Subscription中，然后为每个事件类型创建一个CopyOnWriteArrayList列表subscriptions，并将Subscription插入到subscriptions中。事件类型就是我们post的事件的class对象

2、对粘性事件进行处理

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取事件类型
        Class eventType = subscriberMethod.eventType;
        //将订阅者和订阅方法封装到Subscription中
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //通过事件类型找到Subscription集合
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            //如果还没有订阅类 订阅了该事件的方法，就创建一个list,把当前的Subscription放进去
            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中
        subscribedEvents.add(eventType);

  			//下面这个逻辑可以先不看 后面可以结合postSticky流程看
        //如果订阅方法支持粘性事件
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                Set, Object>> entries = stickyEvents.entrySet();
                //遍历stickyEvents map  这个map保存了粘性事件
                for (Map.Entry, Object> entry : entries) {
                    Class candidateEventType = entry.getKey();
                    //如果当前订阅方法订阅的事件列席在stickyEvents中已经有了，就说明之前某个地方发送过该粘性事件
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        //检查发送粘性事件
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                //检查发送粘性事件
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

走到这里我们的注册逻辑基本就结束了，注册的结果就是得到subscriptionsByEventType和subscribedEvents，

• 1、subscriptionsByEventType是一个map，其中 key是事件类型，value是一个集合，保存了该事件的所有订阅(Subscription)。
• 2、typesBySubscriber也是一个map，其中 key是订阅者，value是一个集合，保存了该订阅者订阅的所有事件。

注册的流程走完了再来看看如何通过注解处理器生成的代码获取SubscriberMethod列表。
下面这个类MyEventBusIndex是注解处理器生成的

public class MyEventBusIndex implements SubscriberInfoIndex {
    private static final Map, SubscriberInfo> SUBSCRIBER_INDEX;

    static {
        key 订阅者类  value 订阅信息
        SUBSCRIBER_INDEX = new HashMap, SubscriberInfo>();
     	//...
        //将订阅信息保存到SUBSCRIBER_INDEX
        putIndex(new SimpleSubscriberInfo(TestRunnerActivity.class, true, new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("onEventMainThread", TestFinishedEvent.class, ThreadMode.MAIN),
            new SubscriberMethodInfo("onEventBackgroundThread", TestEvent.class, ThreadMode.BACKGROUND),
        }));

    }

    private static void putIndex(SubscriberInfo info) {
      	//保存所有订阅类的订阅信息
        SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
    }

    @Override
    public SubscriberInfo getSubscriberInfo(Class subscriberClass) {
        SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
        if (info != null) {
            return info;
        } else {
            return null;
        }
    }
}

SimpleSubscriberInfo定义如下：

public class SimpleSubscriberInfo extends AbstractSubscriberInfo {

    private final SubscriberMethodInfo[] methodInfos;

    public SimpleSubscriberInfo(Class subscriberClass, boolean shouldCheckSuperclass, SubscriberMethodInfo[] methodInfos) {
        super(subscriberClass, null, shouldCheckSuperclass);
        this.methodInfos = methodInfos;
    }

    @Override
    public synchronized SubscriberMethod[] getSubscriberMethods() {
        int length = methodInfos.length;
        SubscriberMethod[] methods = new SubscriberMethod[length];
        for (int i = 0; i < length; i++) {
            SubscriberMethodInfo info = methodInfos[i];
            methods[i] = createSubscriberMethod(info.methodName, info.eventType, info.threadMode,
                    info.priority, info.sticky);
        }
        return methods;
    }
}

MyEventBusIndex类对象会被保存到EventBus的SubscriberMethodFinder中subscriberInfoIndexes成员列表中

private List findUsingInfo(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //找到index类中的订阅信息 ,其实就是调用上面MyEventBusIndex的getSubscriberInfo获取订阅类的SubscriberInfo
            findState.subscriberInfo = getSubscriberInfo(findState);
            if (findState.subscriberInfo != null) {
                //获取SimpleSubscriberInfo的getSubscriberMethods方法获取订阅信息
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    //如果没有添加过，就添加订阅方法
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                //如果index里没有，就通过反射来查找订阅类中的订阅方法
                findUsingReflectionInSingleClass(findState);
            }
            //继续找父类的
            findState.moveToSuperclass();
        }
        //返回订阅方法列表
        return getMethodsAndRelease(findState);
    }

ok到现在为止，注册的逻辑终于结束了。

三、EventBus#unregister流程

public synchronized void unregister(Object subscriber) {
        //获取订阅者订阅的事件列表
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                //通过事件类型解注册
                unsubscribeByEventType(subscriber, eventType);
            }
            //移除
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

最终是通过事件类型来解除该订阅者的所有注册

private void unsubscribeByEventType(Object subscriber, Class eventType) {
        //获取所有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);
                //如果是当前订阅者
                if (subscription.subscriber == subscriber) {
                    //将active 状态改为 false
                    subscription.active = false;
                    //移除订阅关系
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

四、EventBus#post流程

public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List