EventBus源码分析

最近在学习Rxjava，它的思想让我回想起了之前项目中用到的EventBus，事件订阅。但EventBus的具体原理己经记不清，就跑回去看了下它的源码。今天总结下。它的使用方法很简单，不知道如何使用的可以看看我之前写过的一篇博客[不可不知的EventBus]。(http://blog.csdn.net/u014486880/article/details/48449907)

使用差别

在这里还是要说一下，这里分析的是EventBus3.0的源码，3.0的用法跟2.2的用法有点区别，但区别也不大，只是把处理方法换成了注解的形式。如下：

public void onEventMainThread(Event event) {    
    }   

换成了：

@Subscribe(threadMode = ThreadMode.MainThread) //在ui线程执行
    public void onUserEvent(UserEvent event) {
    }

不再需要使得具体的使用就不再详细说了。

EventBus源码

register

入口当然是EventBus.getDefault().register(this)，先看下getDefault()。

public static EventBus getDefault() {
    if (defaultInstance == null ) {
        synchronized (EventBus.class) {
            if (defaultInstance == null ) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}

可见它其实是一个标准的单例模式。再看下register方法：

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

SubscriberMethodFinder类就是用来查找和缓存订阅者响应函数的信息的类。那怎么才能获得订阅者响应函数的相关信息呢。本博客是基于3.0版本的,在3.0版本中，EventBus提供了一个EventBusAnnotationProcessor注解处理器来在编译期通过读取@Subscribe()注解并解析,处理其中所包含的信息,然后生成java类来保存所有订阅者关于订阅的信息,这样就比在运行时使用反射来获得这些订阅者的信息速度要快。来看下findSubscriberMethods怎么执行的：

List  findSubscriberMethods(Class subscriberClass) {
    List subscriberMethods = METHOD_CACHE.get(subscriberClass); //如有缓存存在
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        subscriberMethods = findUsingInfo(subscriberClass);///从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息
    }
    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来进行方法的查找。findUsingReflection是用反射来查找注解@Subscribe从而获取到订阅方法，findUsingInfo是从从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息。这里只分析findUsingReflection的具体流程：

private List findUsingReflection(Class subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass) ;
    while (findState. clazz != null ) {
        findUsingReflectionInSingleClass(findState);
        findState.moveToSuperclass() ;
    }
    return getMethodsAndRelease(findState) ;
}

主要流程在findUsingReflectionInSingleClass中实现：

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() ;
        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)) {
                        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") ;
        }
    }
}

就开始遍历每一个方法了，去匹配封装了。反射读取注解，将method, threadMode, eventType传入构造了：new SubscriberMethod(method, threadMode, eventType)。添加到List。
看下继续往下看moveToSuperclass方法：

void moveToSuperclass() {
    if (skipSuperClasses) {
        clazz = null;
    } else {
        clazz = clazz.getSuperclass() ;
        String clazzName = clazz.getName();
        /** Skip system classes, this just degrades performance. */
        if (clazzName.startsWith("java.") || clazzName.startsWith( "javax.") || clazzName.startsWith("android." )) {
            clazz = null;
        }
    }
}

可以看到，会扫描所有的父类，不仅仅是当前类。
上面说了这么多，其实只要记住一句话：扫描了所有的方法，把匹配的方法最终保存起来。
回到register方法，继续往来就来到subscribe()方法啦，将上面找到的subscriberMethods这个list传入 ：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class eventType = subscriberMethod.eventType ;////获取订阅的事件类型
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod) ;
    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);
        }
    }
// //根据优先级priority来添加Subscription对象
    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事件,立即分发sticky事件
    if (subscriberMethod. sticky) {
        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);
        }
    }
}

上面代码其实也很好理解，首先得到事件类型的所有订阅信息，根据优先级将当前订阅信息插入到订阅者队列subscriptionsByEventType中，得到有序的队列后，就将其放到typesBySubscriber 中。最后判断是否设置了接收sticky事件，如果接收sticky事件，取出sticky事件消息发送给订阅者。

post

分析完register后，就要看看post，是如何分发事件的。
在看源码之前，我们猜测下：register时，把方法存在subscriptionsByEventType；那么post肯定会去subscriptionsByEventType去取，然后调用。

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