EventBus源码解读详细注释（1）register的幕后黑手

[EventBus源码分析（一）：入口函数提纲挈领（2.4版本）](http://blog.csdn.net/wangshihui512/article/details/51802172)
[EventBus源码分析（二）：register方法保存事件的订阅者列表（2.4版本）](http://blog.csdn.net/wangshihui512/article/details/51819508)
[EventBus源码分析（三）：post方法发布事件【获取事件的所有订阅者，反射调用订阅者事件处理方法】（2.4版本）](http://blog.csdn.net/wangshihui512/article/details/51821143)
[EventBus源码分析（四）：线程模型分析（2.4版本）](http://blog.csdn.net/wangshihui512/article/details/51832001)
[EventBus源码解读详细注释（1）register的幕后黑手](http://blog.csdn.net/wangshihui512/article/details/50914817)
[EventBus源码解读详细注释（2）MainThread线程模型分析](http://blog.csdn.net/wangshihui512/article/details/50934012)
[EventBus源码解读详细注释（3）PostThread、MainThread、BackgroundThread、Async四种线程模式的区别](http://blog.csdn.net/wangshihui512/article/details/50935729)
[EventBus源码解读详细注释（4）register时刷新的两个map](http://blog.csdn.net/wangshihui512/article/details/50938663)
[EventBus源码解读详细注释（5）事件消息继承性分析 eventInheritance含义](http://blog.csdn.net/wangshihui512/article/details/50947102)
[EventBus源码解读详细注释（6）从事件发布到事件处理，究竟发生了什么！](http://blog.csdn.net/wangshihui512/article/details/50949960)

register(this)就是去当前类，遍历所有的方法，按照事件处理方法的命名规则约束（onEvent开头，只有一个参数，非static，非abstract的public方法）过滤出事件处理方法然后进行存储。然后循环遍历当前类的父类，做同样的处理。

通过阅读源代码发现如果子类没有覆写父类的事件处理方法，那么父类的事件处理方法将会加入事件处理方法列表。

private synchronized void register(Object subscriber, boolean sticky, int priority) {
    /*getClass():* Returns the unique instance of  Class that represents this object's class.*/
    /*过滤出订阅者的所有事件处理方法（包括父类的），以列表形式返回*/
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass());
    for (SubscriberMethod subscriberMethod : subscriberMethods) {
        /*遍历，对订阅者的每一个事件处理方法进行保存/
        subscribe(subscriber, subscriberMethod, sticky, priority);
    }
}

/**
 * @param subscriberClass
 * @return
 */
/*订阅者 subscriberClass:注册EventBus的Activity或其他组件，EventBus.getDefault().register(this)中的this*/
/*方法findSubscriberMethods的作用是过滤出订阅者的所有事件处理方法方法，以列表形式返回*/
/*在EventBus中的观察者通常有四种订阅函数（就是某件事情发生被调用的方法）
1、onEvent
2、onEventMainThread
3、onEventBackground
4、onEventAsync
这四种订阅函数都是使用onEvent开头的，它们的功能稍有不同,在介绍不同之前先介绍两个概念：
告知观察者事件发生时通过EventBus.post函数实现，这个过程叫做事件的发布，观察者被告知事件发生叫做事件的接收，是通过下面的订阅函数实现的。
onEvent:如果使用onEvent作为订阅函数，那么该事件在哪个线程发布出来的，onEvent就会在哪个线程中运行，也就是说发布事件和接收事件线程在同一个线程。
使用这个方法时，在onEvent方法中不能执行耗时操作，如果执行耗时操作容易导致事件分发延迟。
onEventMainThread:如果使用onEventMainThread作为订阅函数，那么不论事件是在哪个线程中发布出来的，都会在主线程中调用事件处理方法，这个在Android中是非常有用的，因为在Android中只能在UI线程中更新UI，所以在onEvnetMainThread方法中是不能执行耗时操作的。
onEvnetBackground:如果使用onEventBackgrond作为订阅函数，那么如果事件是在UI线程中发布出来的，那么onEventBackground就会在子线程中运行，如果事件本来就是子线程中发布出来的，那么onEventBackground函数直接在该子线程中执行。
onEventAsync：使用这个函数作为订阅函数，那么无论事件在哪个线程发布，都会创建新的子线程在执行onEventAsync.*/
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    /*getName()：Returns the name of the class represented by this Class 返回订阅者的类名，比如xxx.xxx.xxx.MainActivity*/
    String key = subscriberClass.getName();
    List<SubscriberMethod> subscriberMethods;
    /* private static final Map<String, List<SubscriberMethod>> methodCache = new HashMap<String, List<SubscriberMethod>>();*/
    /*方法缓存就是一个静态最终的HashMap，key是订阅者的类名，value是订阅者事件处理方法的列表*/
    /*先读缓存，看能否命中*/
    synchronized (methodCache) {
        subscriberMethods = methodCache.get(key);
    }
    /*如果缓存命中，直接返回缓存中的事件处理方法列表*/
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    /*缓存不命中，开始按照事件处理方法的命名规则进行过滤*/
    subscriberMethods = new ArrayList<SubscriberMethod>();
    Class<?> clazz = subscriberClass;
    /*eventTypesFound存放的是事件处理方法的过滤结果，key就是过滤出来的事件处理方法，value就是声明了这个事件处理方法的订阅者的Class*/
    /*因为是循环处理订阅者的所有父类的，所以如果子类覆写了父类的事件处理方法，那么父类和子类的事件处理方法名称和参数完全一致
    * 而事件处理方法名称和参数是作为eventTypeFound的key存储的，key必须唯一*/
    HashMap<String, Class> eventTypesFound = new HashMap<String, Class>();
    /*注意这个StringBuilder类是在循环外创建的，在循环内创建就太冲动了*/
    StringBuilder methodKeyBuilder = new StringBuilder();
    /*循环的最后一句话：clazz = clazz.getSuperclass(); 表示不仅要找当前类的事件处理方法，还要找所有父类的事件处理方法*/
    while (clazz != null) {
        String name = clazz.getName();
        /*如果类名是以java. javax. android. 为前缀，说明是系统类，不处理系统的类，直接结束循环，这是出于性能的考虑*/
        if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {
            // Skip system classes, this just degrades performance
            break;
        }
        // Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)
        /*从EventBus2.2版本开始要求事件处理方法必须是公开的方法*/
        try {
            // This is faster than getMethods, especially when subscribers a fat classes like Activities
            /*
            getDeclaredMethods()：返回所有方法，不仅仅是公开的，但不包括继承的方法
            getMethods():返回所有公开方法，包括继承来的方法，如果订阅者是个比较复杂的类，那么getDeclaredMethods()速度要快于getMethods()
            getDeclaredMethods()：Returns an array containing  Method objects
            for all methods declared in the class represented by this Class. */
            Method[] methods = clazz.getDeclaredMethods();
            /*对订阅者的所有方法进行过滤，得到事件处理方法列表*/
            filterSubscriberMethods(subscriberMethods, eventTypesFound, methodKeyBuilder, methods);
        } catch (Throwable th) {
            th.printStackTrace();
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            Method[] methods = subscriberClass.getMethods();
            subscriberMethods.clear();
            eventTypesFound.clear();
            filterSubscriberMethods(subscriberMethods, eventTypesFound, methodKeyBuilder, methods);
            break;
        }
        /*获取父类，对订阅者的父类进行同样的处理*/
        clazz = clazz.getSuperclass();
    }
    /*如果组件注册了EventBus，就成为了订阅者，订阅者不能没有事件处理方法，否则抛出异常*/
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass + " has no public methods called "
                + ON_EVENT_METHOD_NAME);
    } else {
        /*过滤一次事件处理方法还是挺麻烦的，所以还是加入缓存吧*/
        synchronized (methodCache) {
            methodCache.put(key, subscriberMethods);
        }
        return subscriberMethods;
    }
}

/**对订阅者的所有方法进行过滤，得到事件处理方法列表
 * @param subscriberMethods 返回的事件处理方法列表
 * @param eventTypesFound  过滤出的时间处理方法
 * @param methodKeyBuilder
 * @param methods 所有方法
 */
private void filterSubscriberMethods(List<SubscriberMethod> subscriberMethods,
                                     HashMap<String, Class> eventTypesFound, StringBuilder methodKeyBuilder,
                                     Method[] methods) {
    /*遍历每个方法，对每个方法进行处理，判断是否为事件处理方法*/
    for (Method method : methods) {
        /*得到方法名*/
        String methodName = method.getName();
        /*private static final String ON_EVENT_METHOD_NAME = "onEvent";*/
        /*如果方法名以onEvent开头就接着处理*/
        if (methodName.startsWith(ON_EVENT_METHOD_NAME)) {
            /*获取该方法的修饰符*/
            int modifiers = method.getModifiers();
            /*获取声明了这个方法的类*/
            /*getDeclaringClass()：returns the class that declares this method.*/
            Class<?> methodClass = method.getDeclaringClass();
            /* private static final int MODIFIERS_IGNORE = Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC;*/
            /*如果是非abstract、static的public方法，接着处理*/
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                /*获取该方法的参数类型列表*/
                Class<?>[] parameterTypes = method.getParameterTypes();
                /*事件处理方法约定只有一个参数*/
                if (parameterTypes.length == 1) {
                    /*根据方法名判断线程类型*/
                    ThreadMode threadMode = getThreadMode(methodClass, method, methodName);
                    /*如果这个方法不是事件处理方法，跳出这次循环*/
                    if (threadMode == null) {
                        continue;
                    }
                    /*获取参数类型，事件处理函数只有一个参数，所以取参数列表的第一项*/
                    Class<?> eventType = parameterTypes[0];
                    methodKeyBuilder.setLength(0);
                    methodKeyBuilder.append(methodName);
                    methodKeyBuilder.append('>').append(eventType.getName());
                    /*举个例子，如果事件处理函数为 onEvent(AutoRefreshMsg msg)
                    * 那么methodKey就为onEvent>AutoRefreshMsg*/
                    String methodKey = methodKeyBuilder.toString();
                    /*HashMap<String, Class> eventTypesFound 是传入的参数*/
                    /*eventTypesFound 中key为onEvent>AutoRefreshMsg这种格式的字符串，value为声明了该事件处理方法的类*/
                    /* HashMap : public V put(K key, V value)
                     * Maps the specified key to the specified value.
                     * @param key the key.
                     * @param value the value.
                     * @return the value of any previous mapping with the specified key or
                     *         code null if there was no such mapping.
                     *         如果HashMap之前没有这样的K V对，或者说是这样的K V对第一次添加到HashMap，就返回null
                     */
                    /* methodClassOld表示之前是否已经存储过了定义了这个事件处理方法的类，如果没有，那么methodClassOld==null*/
                    /*注意HashMap的put方法的返回值，返回对应k之前存储的value或者null如果HashMap*/
                    /*注意对订阅者事件处理方法的过滤是先过滤当前订阅者，然后循环过滤当前订阅者的父类*/
                    /*所以如果子类覆写了父类的事件处理方法，那么肯定先处理子类
                    * 先把此事件处理方法和子类的类Class存储在eventTypesFound
                    * 然后再下一次循环处理父类的时候，调用map的put方法，因为子类覆写了父类的事件处理方法
                    * 所以key值存在，put方法返回之前对用的value，也就是子类的Class*/
                    Class methodClassOld = eventTypesFound.put(methodKey, methodClass);
                    /* public boolean isAssignableFrom(Class<?> c)
                    isAssignableFrom：Can c  be assigned to this class */
                    /* Class<?> methodClass = method.getDeclaringClass();*/
                    /*注意这里或运算的短路性质*/
                    /* instanceof 针对实例  isAssignableFrom针对class对象*/
                    /* new A() instanceof B 判断A对象是否是B类的子类或B类的实例*/
                    /* B.class.isAssignableFrom(A.class) A类是否可以赋值给B类，也就是判断B是不是A的父类*/
 
                    /*对已事件处理方法，子类和父类的都一样，所以只把最底层的订阅者的事件处理方法加入事件处理方法列表
                    *  eventTypesFound需要存储事件处理方法和Class类名，在子类、父类、父类的父类中，事件处理方法名只有把一个（覆写）
                    *  Class名多个，规定只存储最继承层次最底层那个子类的Class作为value*/
                    /*如果子类没有覆写父类的事件处理方法，那么就把父类的事件处理方法加入事件处理方法列表*/
                    if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                        // Only add if not already found in a sub class
                        /*子类中没找到才添加*/
                       /* List<SubscriberMethod> subscriberMethods 方法传进来的参数*/
                        subscriberMethods.add(new SubscriberMethod(method, threadMode, eventType));
                    } else {
                          /*HashMap<String, Class> eventTypesFound 是传入的参数*/
                        /*eventTypesFound 中key为onEvent>AutoRefreshMsg这种格式的字符串，value为声明了该事件处理方法的类*/
                        // Revert the put, old class is further down the class hierarchy
                        /*注意是先处理子类后处理父类*/
                        eventTypesFound.put(methodKey, methodClassOld);
                    }
                }
            } else if (!skipMethodVerificationForClasses.containsKey(methodClass)) {
                Log.d(EventBus.TAG, "Skipping method (not public, static or abstract): " + methodClass + "."
                        + methodName);
            }
        }
    }
}

/**
 * 根据方法名称判断线程类型
 * @param clazz 订阅者
 * @param method
 * @param methodName 以onEvent开头的非static、abstract的public方法
 * @return
 */
private ThreadMode getThreadMode(Class<?> clazz, Method method, String methodName) {
    /*private static final String ON_EVENT_METHOD_NAME = "onEvent";*/
    /*去掉方法名前边的不变量onEvent，留下后边的变量区分线程类型*/
    String modifierString = methodName.substring(ON_EVENT_METHOD_NAME.length());
    ThreadMode threadMode;
    /*四种线程模型*/
    if (modifierString.length() == 0) {
        /*onEvent：回调函数和发起事件的函数会在同一个线程中执行*/
        threadMode = ThreadMode.PostThread;
    } else if (modifierString.equals("MainThread")) {
        /*onEventMainThread：回调函数会在主线程中执行，这个在Android中非常有用，因为在Android中禁止在子线程中修改UI*/
        threadMode = ThreadMode.MainThread;
    } else if (modifierString.equals("BackgroundThread")) {
        /*onEventBackgroundThread：如果在主线程发布事件，那么在子线程中处理该事件；
        吐过在子线程发布事件，那么事件处理方法就在这个子线程执行。*/
        threadMode = ThreadMode.BackgroundThread;
    } else if (modifierString.equals("Async")) {
        /*onEventBusAsync：不管在哪个线程发布事件，都会另起一个线程去处理事件。*/
        threadMode = ThreadMode.Async;
    } else {
        /*private final Map<Class<?>, Class<?>> skipMethodVerificationForClasses;*/
        /*判断是不是可以跳过订阅者方法校验，不跳过就派出异常，跳过就返回null*/
        if (!skipMethodVerificationForClasses.containsKey(clazz)) {
            throw new EventBusException("Illegal onEvent method, check for typos: " + method);
        } else {
            threadMode = null;
        }
    }
    return threadMode;
}