EventBus源码分析

###1、概述
EventBus官方定义是Android和java发布/订阅事件总线。eventbus简化组件之间的通讯，将事件发送和接收着分离，避免复杂且容易的依赖关系和生命周期，支持黏性事件。

###2、源码分析
EventBus分为事件发布者和订阅者，先从事件订阅者分析。我们在使用EventBus时通过EventBus.getDefualt()获取EventBus实例对象，通过regester()方法订阅事件。

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

获取EventBus通过单例双检查机制获取实例对象，获取EventBus对象后通过register方法注册事件，

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

在register方法中获取当前注册者class对象，然后通过SubsrciberMethodFinder对象通过反射获取class对象中注解方法，在register方法中通过调用subscribeMethodFinder.findSubscriberMethods方法获取注解方法

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    List<SubscriberMethod> 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;
    }
}

在findSubscriberMethods中先通过Method_Cache查找是否已经有缓存，Method_Cache是一个Map对象，key为注册class对象，value为SubscribleMeMethod对象，有缓存返回缓存中SubscriberMetod集合，没有通过反射获取注册者中被订阅的方法

	private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        findState.subscriberInfo = getSubscriberInfo(findState);
        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 {
            findUsingReflectionInSingleClass(findState);
        }
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

在通过findUsingInfo方法查找注册者订阅方法时，EventBus会创建FindState对象，通过FindState辅助查找当前注册对象获者当前父类中订阅的方法，在EventBus中创建一个大小为4的FindState集合，在findUsingInfo中获取findState对象判断当前集合中是否有可以复用的FindState对象，没有创建FindState对象放入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");
        }
    }
}

在findUsingReflectionInSingleClass方法中获取订阅者中所有的方法，判断方法的修饰符和方法参数，如果当前方法中有一个事件类型参数判断当前方法是否有@Subscribe注解，如果有Subscribe注解获取注解中线程模式、是否支持黏性事件、事件类型组装一个SubscribeMetod对象存储FindState字段中，返回到regster中，获取到SubscribeMetod后，遍历SubscribeMethod集合，通过过调用subscribe方法传入当前订阅者和订阅者中有Subscribe方法的集合，在Subscribe中创建一个Subscription对象存储订阅者和SubscribeMethod对象，放入subscriptionsByEventType集合中，创建一个typeBySubscriber map集合存储被订阅者对象和订阅事件类型，然后判断是否有黏性事件接受订阅，在接受黏性事件时判断继承中订阅方法，通过调用checkPostStictyEventToSubscription接受黏性事件，通过stictyEvent中获取黏性事件，通过反射调用订阅者中@Subscribe方法。

 private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    CopyOnWriteArrayList<Subscription> 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<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);

    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<Class>).
            Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry<Class<?>, 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);
        }
    }
}

在分析post中的方法，在post中我们通过发射事件类型对象，在post通过Thread中TheadLoaclMap获取ThreadLoacl 存储PostingThreadState对象，把当前event事件加入队列中，判断队列是否正在运行，没有运行遍历队列通过调用postSingleEvent方法，处理事件发送，在postSingleEvent中通过subscriptionsByEventType获取在register中封装的subsciptions集合，遍历集合通过调用postToSubscription方法调用method.invoke方法，在postToSubscription中判断订阅者中@Subsrcibe注解方法线程，如果是Posting就是当前post调用线程中执行，Main通过mianThreadPoster切换线程执行，Asyc通过asynPoster通过EventBus线程池做线程切换。

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

    if (!postingState.isPosting) {
        postingState.isMainThread = isMainThread();
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
            while (!eventQueue.isEmpty()) {
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}

###3、总结
EventBus通过register注册，分为两种普通订阅和黏性订阅事件，在register中通过通过subscriberMethodFinder对象查找订阅者中订阅方法，在subscriberMethodFinder中通过FindState使用反射获取@Subscribe注解中的方法，获取方法执行线程是否黏性事件等，EventBus维护一个大小为4的FindState集合，提供重复使用，查找被注解的方法后封装成SubscriberMethod，把SubscriberMethod放到Map缓存中，下次重新打开activity或者订阅者不需要通过反射获取，当前map集合是ConcurrentHashmap保证线程安全，register查找订阅方法后把订阅对象和SubsciblerMethod存在到Subscription中，判断是否有黏性事件，如果StickEvent不为空，遍历Subsciptions集合如果eventType类型一样发射事件，用户通过post发射事件时是通过遍历register中Subscription集合，通过反射调用订阅者中方法，在subscription中存储着订阅者对象和方法。