标签：
EventBus是一款针对Android优化的发布/订阅事件总线库。简便了Activities, Fragments, 以及background threads之间的通信，使发送者与订阅者之间有效解耦。
EventBus的使用也极其简单，只需三步即可。
定义一个事件类型。
public class MessageEvent {
public final String message;
public MessageEvent(String message) {
this.message = message;
}
}准备订阅者
只需给一个public方法添加@Subscribe注解，那么当发布事件时，订阅者就能匹配并接受处理事件。
// This method will be called when a MessageEvent is posted
@Subscribe
public void onMessageEvent(MessageEvent event){
Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}
// This method will be called when a SomeOtherEvent is posted
@Subscribe
public void handleSomethingElse(SomeOtherEvent event){
doSomethingWith(event);
}所有的订阅者都应该在事件总线中被注册。只有被注册的订阅者才能收到事件。
@Override
public void onStart() {
super.onStart();
EventBus.getDefault().register(this);
}
@Override
public void onStop() {
EventBus.getDefault().unregister(this);
super.onStop();
}发布事件
你可以在代码的任何地方发布事件，所有更当前事件类型匹配的订阅者都可以接收到这个事件。
EventBus.getDefault().post(new MessageEvent("Hello everyone!"));EventBus是一个非常小巧的库，但是功能却足够强大，接下来去源码里看看。
我们从EventBus.getDefault().register(this);这一行开始，看看getDefault()做了什么？
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}可以看出，保持了一个单例。EventBus的构造方法如下。
//=================这两个集合很重要，后面经常出现 START========================
//key为事件类型，value为订阅关系列表。用于查询订阅了该事件的所有订阅关系列表，下称事件类型集合
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
//key为订阅者，value为订阅者中的事件类型列表。用于查询该订阅者订阅了的事件。下称订阅者集合
private final Map<Object, List<Class<?>>> typesBySubscriber;
//=======================这两个集合很重要，后面经常出现 END==================
//粘性事件，只保留最近一次的事件（相同事件类型只保留一次）
private final Map<Class<?>, Object> stickyEvents;
//存放SubscriberInfo索引
private List<SubscriberInfoIndex> subscriberInfoIndexes;
//事件类型缓存，key为事件类型，value为当前事件类型继承的所有事件类型
private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<>();
//主线程发布者
private final HandlerPoster mainThreadPoster;
//子线程发布者（串行）
private final BackgroundPoster backgroundPoster;
//子线程发布者（另开一个线程）
private final AsyncPoster asyncPoster;
//订阅方法查找器
private final SubscriberMethodFinder subscriberMethodFinder;
//线程池，用于在子线程中发布事件
private final ExecutorService executorService;
private final boolean throwSubscriberException;
private final boolean logSubscriberExceptions;
private final boolean logNoSubscriberMessages;
private final boolean sendSubscriberExceptionEvent;
private final boolean sendNoSubscriberEvent;
private final boolean eventInheritance;
private final int indexCount;
public EventBus() {
this(DEFAULT_BUILDER);
}
//构造方法
EventBus(EventBusBuilder builder) {
//初始化事件类型集合
subscriptionsByEventType = new HashMap<>();
//初始化订阅者集合
typesBySubscriber = new HashMap<>();
//粘性事件集合
stickyEvents = new ConcurrentHashMap<>();
//主线程发布者
mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
//子线程发布者（串行，保持只有一个线程）
backgroundPoster = new BackgroundPoster(this);
//子线程发布者（并行，新起一个线程）
asyncPoster = new AsyncPoster(this);
//以下通过EventBusBuilder进行赋值
indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
//订阅方法查找器。
subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
builder.strictMethodVerification, builder.ignoreGeneratedIndex);
//是否打印/抛出/发送错误
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
//是否支持继承下来的事件
eventInheritance = builder.eventInheritance;
//线程池
executorService = builder.executorService;
}代码有点长，看的可能有点晕，从源码可以看出最终构造方法中会传入EventBusBuilder对象进行赋值初始化，EventBusBuilder用来配置信息。构造方法主要就是初始化环境。
我们现在就来看看register中的源码。
public void register(Object subscriber) {
//获取Class对象
Class<?> subscriberClass = subscriber.getClass();
//通过方法查找器寻找该订阅者中的订阅方法。
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//加入到集合中保存
subscribe(subscriber, subscriberMethod);
}
}
}代码很简练，思路也比较清晰。首先获取订阅者的Class对象，然后通过订阅者方法查找器（SubscriberMethodFinder）查询该订阅者中的订阅方法并返回，最后通过subscribe存入到相关集合中。
在介绍SubscriberMethodFinder之前我们先来了解一下其他几个类。
Subscribe用来给订阅方法进行注解，可以指定线程模型，优先级，是否粘性等等。
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
ThreadMode threadMode() default ThreadMode.POSTING;
boolean sticky() default false;
int priority() default 0;
}ThreadMode是个枚举类，可以指定四种线程模型。
public enum ThreadMode {
//表示在哪个线程发布事件就在哪个线程接收事件
POSTING,
//表示在主线程接收事件
MAIN,
//表示在子线程接收事件
BACKGROUND,
//表示开启一个线程接收事件
ASYNC
}通过类名就可以猜出这个类肯定是用来包装订阅方法的，里面存放了方法、线程模型、事件类型（订阅方法中那个参数类型），优先级、是否粘性等。
public class SubscriberMethod {
final Method method;//订阅方法
final ThreadMode threadMode;//线程模型
final Class<?> eventType;//事件类型（就是订阅方法的参数类型）
final int priority;//优先级
final boolean sticky;//是否粘性
public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
this.method = method;
this.threadMode = threadMode;
this.eventType = eventType;
this.priority = priority;
this.sticky = sticky;
}
//..
//省略部分源码
}FindState是一个临时存储订阅方法的类，在查找完毕后就会被回收。
static class FindState {
//存储订阅方法的集合
final List<SubscriberMethod> subscriberMethods = new ArrayList<>();
//根据事件类型存储订阅方法，用来判断是不是该事件已经被添加过了
final Map<Class, Object> anyMethodByEventType = new HashMap<>();
//根据方法名生成的key存储订阅者的类
final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();
//方法key生成器
final StringBuilder methodKeyBuilder = new StringBuilder(128);
Class<?> subscriberClass;//订阅者的父类
Class<?> clazz;//当前订阅者
boolean skipSuperClasses;//是否跳过父类
SubscriberInfo subscriberInfo;//这个用于注解生成器
//初始化FindState
void initForSubscriber(Class<?> subscriberClass) {
this.subscriberClass = clazz = subscriberClass;
skipSuperClasses = false;
subscriberInfo = null;
}
//回收FindState
void recycle() {
subscriberMethods.clear();
anyMethodByEventType.clear();
subscriberClassByMethodKey.clear();
methodKeyBuilder.setLength(0);
subscriberClass = null;
clazz = null;
skipSuperClasses = false;
subscriberInfo = null;
}
//..
//省略了部分源码
}Subscription表示订阅关系，由订阅者和订阅者方法构成。
final class Subscription {
final Object subscriber;//订阅者
final SubscriberMethod subscriberMethod;//订阅者方法
volatile boolean active;
Subscription(Object subscriber, SubscriberMethod subscriberMethod) {
this.subscriber = subscriber;
this.subscriberMethod = subscriberMethod;
active = true;
}
//..
//省略了部分源码
}现在我们回过头来看看SubscriberMethodFinder的findSubscriberMethods方法。
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//看看集合中有没有缓存
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
//是否忽略注解器生成的Index类
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;
}
}一般如果不引用注解生成器，就会直接走反射查找这个路线。
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
//获取一个临时保存订阅信息的FindState类
FindState findState = prepareFindState();
//初始化基本信息（其实就是把subscriberClass赋值给findState.clazz）
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
//查找订阅方法
findUsingReflectionInSingleClass(findState);
//定位到父类（就是把父类赋值给findState.clazz，默认跳过系统类）
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);//从FindState类中取出方法集合，然后释放资源。
}默认会保持4个FindState循环利用，prepareFindState就是取出一个FindState。然后通过findUsingReflectionInSingleClass将订阅方法集合暂时保存在FindState中。
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
//反射获取方法
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
//循环遍历所有的方法
for (Method method : methods) {
int modifiers = method.getModifiers();//获取修饰符
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {//必须为public
Class<?>[] parameterTypes = method.getParameterTypes();获取方法的参数类型。
if (parameterTypes.length == 1) {//只能包含一个参数
//获取Subscribe注解
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
Class<?> eventType = parameterTypes[0];
//判断是否没有添加过
if (findState.checkAdd(method, eventType)) {
//获取线程模型等信息
ThreadMode threadMode = subscribeAnnotation.threadMode();
//添加到FindState中的subscriberMethods集合类
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
}
//...
//省略了else中的代码
}
}findUsingReflectionInSingleClass方法主要用于遍历匹配方法，如果满足条件就添加到FindState中的subscriberMethods集合进行保存。既然订阅方法已经遍历完了，那么现在我们回到register方法中。
可以看出会对每个方法进行遍历然后执行subscribe。
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
//获取事件类型（就是方法里的那个参数类型）
Class<?> eventType = subscriberMethod.eventType;
//用Subscription包装subscriberMethod，可以看出将订阅者与订阅方法给关联了起来。
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
//看看事件类型集合里是不是存在过之前的事件类型（ CopyOnWriteArrayList是线程安全的）
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {//没有当前事件类型的集合
//第一次须初始化列表
subscriptions = new CopyOnWriteArrayList<>();
//subscriptions为空表示之前没有相同的类型，那么现在就塞进去
subscriptionsByEventType.put(eventType, subscriptions);
} else {
//subscriptions不为空说明有相同事件类型的，判断列表里是不是已经包含了，包含就抛出异常
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) {
//没有就给当前订阅者new个事件列表放进去
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
//当到该订阅者下的事件列表里
subscribedEvents.add(eventType);
//判断是不是粘性方法
if (subscriberMethod.sticky) {
if (eventInheritance) {//是否可以响应继承？
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);
}
}
}代码有点长，但是逻辑并不复杂，可以看出把订阅方法循环添加到了集合中。然后检查有没有粘性方法，如果有就将最近一次的粘性事件发布即可。
接下来看解除事件，为什么不先看发布事件？因为注册和解除是互相呼应的，而且比较简单。趁热看，免得之后又被几个集合给搞懵逼了（说的就是我）。
public synchronized void unregister(Object subscriber) {
//根据订阅者查询该订阅者有哪些事件
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
for (Class<?> eventType : subscribedTypes) {
//从事件类型集合中移除
unsubscribeByEventType(subscriber, eventType);
}
//从订阅者集合中移除
typesBySubscriber.remove(subscriber);
} else {
Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}我们知道，注册事件时会将订阅者以及订阅事件保存到集合中，那么解除事件毋容置疑，首先去集合中查询有没有，如果有，把它从事件类型集合中移除，然后从订阅者集合中移除。unsubscribeByEventType源码如下。
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions != null) {
int size = subscriptions.size();
//遍历事件集合，移除相关订阅信息。
for (int i = 0; i < size; i++) {
Subscription subscription = subscriptions.get(i);//根据事件类型遍历订阅关系
if (subscription.subscriber == subscriber) {//如果订阅者相同
subscription.active = false;
subscriptions.remove(i);//移除
i--;
size--;
}
}
}
}发布事件用ThreadLocal保存了PostingThreadState，PostingThreadState是一个保存事件的类。然后通过循环发送单个事件，可以看出发布事件是串行执行的。
/** Posts the given event to the event bus. */
public void post(Object event) {
//PostingThreadState类似于FindState，用于保存要发布的事件，里面有一个事件队列
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);//添加到事件队列中
if (!postingState.isPosting) {
postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
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;
}
}
}PostingThreadState的源码如下。
final static class PostingThreadState {
final List<Object> eventQueue = new ArrayList<Object>();//事件列表
boolean isPosting;//是否正在发布事件
boolean isMainThread;//是否在主线程
Subscription subscription; //订阅关系
Object event; //事件
boolean canceled;//是否已被取消
}接下来看看postSingleEvent方法。如果可以响应事件继承就获取当前事件类型的所有父类。然后逐个发布事件。
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();//获取事件类型
boolean subscriptionFound = false;//是否寻找到订阅关系
if (eventInheritance) {//事件继承？
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);//循环遍历所有继承事件类型
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
//循环发送事件（包括继承事件）
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
//发送事件
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
//..
//省略了部分源码
}可以看出，最终通过postSingleEventForEventType来发布事件。
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;//订阅关系列表
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);//取出订阅关系礼拜
}
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
//根据订阅关系发布事件
postToSubscription(subscription, event, postingState.isMainThread);
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
postToSubscription中即是根据订阅关系发布事件。根据不同的线程模型使用不同发布者进行发布。
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING:
invokeSubscriber(subscription, event);
break;
case MAIN:
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
break;
case BACKGROUND:
if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
case ASYNC:
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}最终通过反射发布事件。我们只来看一下POSTING源码。其他就不赘述了，操作基本大同小异。
void invokeSubscriber(Subscription subscription, Object event) {
try {
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);//发射调用方法。
} catch (InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
} catch (IllegalAccessException e) {
throw new IllegalStateException("Unexpected exception", e);
}
}
到此为止，整个EventBus工作流程已经梳理完毕。
注解生成器，就是在编译的时候根据注解生成特定的类。就跟自己写的源码一样，执行效率比反射要高很多。
我们在分析subscriberMethodFinder.findSubscriberMethods查找方法时，提到一般只会走反射，所以没有关心通过注解生成器查找的步骤。
//是否忽略注解器生成的Index类
if (ignoreGeneratedIndex) {
//通过反射查找
subscriberMethods = findUsingReflection(subscriberClass);
} else {
//通过注解生成器生成的类查找
subscriberMethods = findUsingInfo(subscriberClass);
}现在我们来看下findUsingInfo源码。
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
//初始化FindState
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
findState.subscriberInfo = getSubscriberInfo(findState);//获取注解器生成的SubscriberInfo
if (findState.subscriberInfo != null) {
//如果找到了SubscriberInfo就获取方法
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);
}SubscriberInfo信息如下。
public interface SubscriberInfo {
Class<?> getSubscriberClass();//获取父类
SubscriberMethod[] getSubscriberMethods();//获取订阅方法
SubscriberInfo getSuperSubscriberInfo();//获取父类订阅者信息
boolean shouldCheckSuperclass();
}getSubscriberInfo用来根据订阅者获取SubscriberInfo。
private SubscriberInfo getSubscriberInfo(FindState findState) {
if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
if (findState.clazz == superclassInfo.getSubscriberClass()) {
return superclassInfo;
}
}
//SubscriberInfoIndex中获取SubscriberInfo
if (subscriberInfoIndexes != null) {
for (SubscriberInfoIndex index : subscriberInfoIndexes) {
SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
if (info != null) {
return info;
}
}
}
return null;
}EventBus中注解生成器生成代码。
private void createInfoIndexFile(String index) {
BufferedWriter writer = null;
try {
JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(index);
int period = index.lastIndexOf(‘.‘);
String myPackage = period > 0 ? index.substring(0, period) : null;
String clazz = index.substring(period + 1);
writer = new BufferedWriter(sourceFile.openWriter());
if (myPackage != null) {
writer.write("package " + myPackage + ";\n\n");
}
writer.write("import org.greenrobot.eventbus.meta.SimpleSubscriberInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberMethodInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberInfo;\n");
writer.write("import org.greenrobot.eventbus.meta.SubscriberInfoIndex;\n\n");
writer.write("import org.greenrobot.eventbus.ThreadMode;\n\n");
writer.write("import java.util.HashMap;\n");
writer.write("import java.util.Map;\n\n");
writer.write("/** This class is generated by EventBus, do not edit. */\n");
writer.write("public class " + clazz + " implements SubscriberInfoIndex {\n");
writer.write(" private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;\n\n");
writer.write(" static {\n");
writer.write(" SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();\n\n");
writeIndexLines(writer, myPackage);
writer.write(" }\n\n");
writer.write(" private static void putIndex(SubscriberInfo info) {\n");
writer.write(" SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);\n");
writer.write(" }\n\n");
writer.write(" @Override\n");
writer.write(" public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {\n");
writer.write(" SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);\n");
writer.write(" if (info != null) {\n");
writer.write(" return info;\n");
writer.write(" } else {\n");
writer.write(" return null;\n");
writer.write(" }\n");
writer.write(" }\n");
writer.write("}\n");
} catch (IOException e) {
throw new RuntimeException("Could not write source for " + index, e);
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
//Silent
}
}
}
}writeIndexLines写入订阅者相关的订阅方法信息
private void writeIndexLines(BufferedWriter writer, String myPackage) throws IOException {
for (TypeElement subscriberTypeElement : methodsByClass.keySet()) {
if (classesToSkip.contains(subscriberTypeElement)) {
continue;
}
String subscriberClass = getClassString(subscriberTypeElement, myPackage);
if (isVisible(myPackage, subscriberTypeElement)) {
writeLine(writer, 2,
"putIndex(new SimpleSubscriberInfo(" + subscriberClass + ".class,",
"true,", "new SubscriberMethodInfo[] {");
List<ExecutableElement> methods = methodsByClass.get(subscriberTypeElement);
writeCreateSubscriberMethods(writer, methods, "new SubscriberMethodInfo", myPackage);
writer.write(" }));\n\n");
} else {
writer.write(" // Subscriber not visible to index: " + subscriberClass + "\n");
}
}
}大家只要知道注解生成器是用来干嘛的就行了，关于注解生成器的原理和使用方法，改篇再作深究，有兴趣的可以自行查阅AnnotationProcessor资料。
标签：
原文地址：http://blog.csdn.net/maplejaw_/article/details/51594860
