EventBus源码解读详细注释（4）register时刷新的两个map

[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)

EventBus中有两个重要的map，一个是事件到订阅者列表的map，另一个是订阅者到事件列表的map，每次register的时候都要动态刷新这两个map的数据。正是因为有了这两个map，EventBus在post事件的时候才可以根据事件类型找到所有订阅了此事件的订阅者，然后使用反射调用订阅者的事件处理方法。

先看看EventBus中这两个map是如何定义的

/*事件到订阅者列表的map，key是事件，也就是消息处理方法的参数的Class，value是所有的订阅此事件的订阅者列表*/
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
/*订阅者到订阅者订阅的所有事件列表的map，key是订阅者，value是该订阅者订阅的所有事件的列表*/
private final Map<Object, List<Class<?>>> typesBySubscriber;

在register的时候会动态的刷新这两个map，主要是刷新map的value即刷新列表。

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);
}
}

subscribe方法中主要做了一件事，就是更新那两个重要的map

/**
* @param subscriber 订阅者
* @param subscriberMethod 订阅者的事件处理方法
* @param sticky 是否是粘性事件
* @param priority 优先级
*/
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod, boolean sticky, int priority) {
/*每次subscribe都要更新两个map，事件到订阅者列表的map，和订阅者到事件列表的map*/
/*下边的代码先更新事件到订阅者列表的map，主要是更新此事件的订阅者列表*/
/*获取消息类型，也就是事件处理方法的参数类型*/
Class<?> eventType = subscriberMethod.eventType;
/*private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
* subscriptionsByEventType: key:消息类型（事件处理方法参数类型），value：接受此消息类型的所有订阅者列表
* */
/*获取所有接受此消息类型的订阅者列表，然后把新的订阅者加入此列表*/
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
/*根据订阅者，事件、优先级封装一个新的订阅者封装类Subscription*/
Subscription newSubscription = new Subscription(subscriber, subscriberMethod, priority);
/*如果此消息类型的订阅者列表为null，表示还没有订阅者订阅此类型消息，就创建一个订阅者列表*/
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<Subscription>();
/*将事件和事件对应的订阅者列表加入全局的map*/
subscriptionsByEventType.put(eventType, subscriptions);
} else {
/*如果接收此消息类型的订阅者列表不为空，并且列表里边已经有此订阅者，抛出重复注册异常*/
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}

// Starting with EventBus 2.2 we enforced methods to be public (might change with annotations again)
// subscriberMethod.method.setAccessible(true);
/*更新事件的订阅者列表*/
/*将新的注册的订阅者根据优先级插入到合适位置，priority表示优先级，按照该数值从大到小排列*/
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
/*按照优先级遍历 逐个比较*/
if (i == size || newSubscription.priority > subscriptions.get(i).priority) {
/*注意写时复制的思想，CopyOnWriteArrayList增加数据的源代码如下所示*/
/*
public synchronized void add(int index, E e) {
Object[] newElements = new Object[elements.length + 1];

public static native void arraycopy(Object src, int srcPos,Object dst, int dstPos, int length);
* Copies length elements from the array src,
* starting at offset srcPos, into the array dst,
* starting at offset dstPos.
* @param src the source array to copy the content.
* @param srcPos  the starting index of the content in {@code src}.
* @param dst the destination array to copy the data into.
* @param dstPos the starting index for the copied content in {@code dst}.
* @param length the number of elements to be copied.

System.arraycopy(elements, 0, newElements, 0, index);
newElements[index] = e;
System.arraycopy(elements, index, newElements, index + 1, elements.length - index);
elements = newElements;
}
*/
/*CopyOnWriteArrayList并不是按照数据结构里边将的那样通过数据移位来添加元素，那样效率太低了
* 而是先创建一个比原来列表size大1的新列表，将新添加数据前边的所有数据整体赋值到新列表前边，
* 将要添加的新数添加在新列表的后边，然后把剩下的一起复制到新列表*/
subscriptions.add(i, newSubscription);
break;
}
}
/*然后接下来更新订阅者到事件列表的map，主要是更新事件列表*/
/*private final Map<Object, List<Class<?>>> typesBySubscriber;
* typesBySubscriber ：key订阅者 value订阅者订阅的消息列表
* typesBySubscriber是EventBus的成员属性，表示一个map，key是订阅者，value是该订阅者订阅的所有事件的列表，
* 是全局的，要囊括所有订阅者
* subscriptionsByEventType也是EventBus的成员属性，表示一个map，key是事件，value是订阅了改事件的所有订阅者的列表，
* 是全局的，要囊括所有事件*/
/*获取订阅者的接受的所有消息类型列表*/
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
/*如果此订阅者还没有以前没有订阅事件，则创建列表，添加事件*/
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<Class<?>>();
/*typesBySubscriber是EventBus的类成员*/
typesBySubscriber.put(subscriber, subscribedEvents);
}
/*将此事件添加到订阅者订阅的事件的列表，更新事件列表*/
subscribedEvents.add(eventType);
/*处理粘性事件*/
if (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);
}
}
}