findUsingInfo（Class>subscriberClass）{
FindStatefindState=prepareFindState（）;
findState.initForSubscriber（subscriberClass）;
//初始状态下findState.clazz就是subscriberClass
while（findState.clazz!
=null）{
findState.subscriberInfo=getSubscriberInfo（findState）;
//条件不成立
if（findState.subscriberInfo!
=null）{
SubscriberMethod[]array=findState.subscriberInfo.getSubscriberMethods（）;
for（SubscriberMethodsubscriberMethod:
array）{
if（findState.checkAdd（subscriberMethod.method,subscriberMethod.eventType））{
findState.subscriberMethods.add（subscriberMethod）;
}
}
}else{
//通过反射查找订阅事件的方法
findUsingReflectionInSingleClass（findState）;
}
//修改findState.clazz为subscriberClass的父类Class，即需要遍历父类
findState.moveToSuperclass（）;
}
//查找到的方法保存在了FindState实例的subscriberMethods集合中。
//使用subscriberMethods构建一个新的List
//释放掉findState
returngetMethodsAndRelease（findState）;
}
2.2.3.2FindUsingInfo
该方法会在当前类及父类查找订阅事件的方法，这里还引用了一个FindState静态内部类，用来辅助查找订阅事件的方法，具体的查找过程在findUsingReflectSingleClass（）方法中，主要通过反射查找订阅事件；
privatevoidfindUsingReflectionInSingleClass（FindStatefindState）{
Method[]methods;
try{
//ThisisfasterthangetMethods,especiallywhensubscribersarefatclasseslikeActivities
methods=findState.clazz.getDeclaredMethods（）;
}catch（Throwableth）{
//Workaroundforjava.lang.NoClassDefFoundError,see
methods=findState.clazz.getMethods（）;
findState.skipSuperClasses=true;
}
//循环遍历当前类的方法，筛选出符合条件的
for（Methodmethod:
methods）{
//获得方法的修饰符
intmodifiers=method.getModifiers（）;
//如果是public类型，但非abstract、static等
if（（modifiers&Modifier.PUBLIC）!
=0&&（modifiers&MODIFIERS_IGNORE）==0）{
//获得当前方法所有参数的类型
Class
>[]parameterTypes=method.getParameterTypes（）;
//如果当前方法只有一个参数
if（parameterTypes.length==1）{
SubscribesubscribeAnnotation=method.getAnnotation（Subscribe.class）;
//如果当前方法使用了Subscribe注解
if（subscribeAnnotation!
=null）{
//得到该参数的类型
Class
>eventType=parameterTypes[0];
//checkAdd（）方法用来判断FindState的anyMethodByEventTypemap是否已经添加过以当前
eventType为key的键值对，没添加过则返回true
if（findState.checkAdd（method,eventType））{
//得到Subscribe注解的threadMode属性值，即线程模式
ThreadModethreadMode=subscribeAnnotation.threadMode（）;
//创建一个SubscriberMethod对象，并添加到subscriberMethods集合
findState.subscriberMethods.add（newSubscriberMethod（method,eventType,threadMode,
subscribeAnnotation.priority（）,subscribeAnnotation.sticky（）））;
}
}
}elseif（strictMethodVerification&&method.isAnnotationPresent（Subscribe.class））{
StringmethodName=method.getDeclaringClass（）.getName（）+"."+method.getName（）;
thrownewEventBusException（"@Subscribemethod"+methodName+
"musthaveexactly1parameterbuthas"+parameterTypes.length）;
}
}elseif（strictMethodVerification&&method.isAnnotationPresent（Subscribe.class））{
StringmethodName=method.getDeclaringClass（）.getName（）+"."+method.getName（）;
thrownewEventBusException（methodName+
"isaillegal@Subscribemethod:
mustbepublic,non-static,andnon-abstract"）;
}
}
}
到此register（）方法中findSubscriberMethods（）流程就分析完了，已经找到当前注册类及其父类订阅事件方法的集合，下面是具体的注册流程，即register的subscriber（）方法。
2.2.3.3subscriber（）方法
privatevoidsubscribe（Objectsubscriber,SubscriberMethodsubscriberMethod）{
//得到当前订阅了事件的方法的参数类型
Class
>eventType=subscriberMethod.eventType;
//Subscription类保存了要注册的类对象以及当前的subscriberMethod
SubscriptionnewSubscription=newSubscription（subscriber,subscriberMethod）;
//subscriptionsByEventType是一个HashMap，保存了以eventType为key,Subscription对象集合为value的键值对
//先查找subscriptionsByEventType是否存在以当前eventType为key的值
CopyOnWriteArrayListsubscriptions=subscriptionsByEventType.get（eventType）;
if（subscriptions==null）{
subscriptions=newCopyOnWriteArrayList<>（）;
subscriptionsByEventType.put（eventType,subscriptions）;
}else{
if（subscriptions.contains（newSubscription））{
thrownewEventBusException（"Subscriber"+subscriber.getClass（）+"alreadyregisteredtoevent"
+eventType）;
}
}
//添加上边创建的newSubscription对象到subscriptions中
intsize=subscriptions.size（）;
for（inti=0;i<=size;i++）{
if（i==size||subscriberMethod.priority>subscriptions.get（i）.subscriberMethod.priority）{
subscriptions.add（i,newSubscription）;
break;
}
}
//typesBySubscribere也是一个HashMap，保存了以当前要注册类的对象为key，
//注册类中订阅事件的方法的参数类型的集合为value的键值对
//查找是否存在对应的参数类型集合
List>>subscribedEvents=typesBySubscriber.get（subscriber）;
if（subscribedEvents==null）{
//不存在则创建一个subscribedEvents，并保存到typesBySubscriber
subscribedEvents=newArrayList<>（）;
typesBySubscriber.put（subscriber,subscribedEvents）;
}
//保存当前订阅了事件的方法的参数类型
subscribedEvents.add（eventType）;
if（subscriberMethod.sticky）{
if（eventInheritance）{
//ExistingstickyeventsofallsubclassesofeventTypehavetobeconsidered.
//Note:
Iteratingoveralleventsmaybeinefficientwithlotsofstickyevents,
//thusdatastructureshouldbechangedtoallowamoreefficientlookup
//（e.g.anadditionalmapstoringsubclassesofsuperclasses:
Class->List）.
Set>,Object>>entries=stickyEvents.entrySet（）;
for（Map.Entry>,Object>entry:
entries）{
Class
>candidateEventType=entry.getKey（）;
if（eventType.isAssignableFrom（candidateEventType））{
ObjectstickyEvent=entry.getValue（）;
checkPostStickyEventToSubscription（newSubscription,stickyEvent）;
}
}
}else{
ObjectstickyEvent=stickyEvents.get（eventType）;
checkPostStickyEventToSubscription（newSubscription,stickyEvent）;
}
}
}
Subscriber（）方法主要是为了得到subscriptionsByEventType、TypesBySubscriber两个HashMap，在发送事件时要用到subscriptionsByEventType，完成时间的处理，当取消EventBus注册时则要用到TypesBySubscriber、subscriptionsByEventType完成相关资源的释放；
下面是取消注册：
EventBus.getDefault.unRegister（this）,其核心的方法就是unsubscriberByEventType（）；
publicsynchronizedvoidunregister（Objectsubscriber）{
//得到当前注册类对象对应的订阅事件方法的参数类型的集合
List>>subscribedTypes=typesBySubscriber.get（subscriber）;
if（subscribedTypes!
=null）{
//遍历参数类型集合，释放之前缓存的当前类中的Subscription
for（Class
>eventType:
subscribedTypes）{
unsubscribeByEventType（subscriber,eventType）;
}
//删除以subscriber为key的键值对
typesBySubscriber.remove（subscriber）;
}else{
Log.w（TAG,"Subscribertounregisterwasnotregisteredbefore:
"+subscriber.getClass（））;
}
}
然后再看下unsubscribe
升级会员 