简读Eventbus3.0
简单了解一下eventbus的工作情况，学学大神的思想，那么在此篇文章之前呢，建议大家先要了解清楚何为注解和反射，如果没了解，可以先看看前一篇文章，有具体的介绍 Android 注解 （Annotation）
使用过eventbus的都知道，eventbus是一个Android事件发布/订阅轻量级框架， 它可以完美的在任何地方完成通信任务，那么不废话啦，按照 咱们在Android中的使用过程为思路展开一个了解吧
一、我们是在需要接受事件的地方(例如activity、fragment) 注册 eventbus事件
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(...);
//注册eventbus事件
EventBus.getDefault().register(this);
}好啦，如上代码，我们在activity的oncreate生命周期方法中注册了eventbus事件，那么来看一下 getDefault()、register()方法到底干了点什么
//第一部分，获取单例（懒汉式，"懒得创建自己"）
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
//第二部分，注册给定的订阅服务器以接收事件。订阅者必须调用{unregister(Object)取消注册（对象）}
public void register(Object subscriber) {
//1.首先通过反射获取到当前类
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//2
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);//3
}
}
}第一部分 EventBus.getDefault() 是一个懒汉式单例。
第二部分是注册，1.首先通过当前object.getclass()反射方法获取到当前 class对象； 2.然后通过 findSubscriberMethods 方法获取到一个当前class对象的所有方法，并放在一个list集合中，List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass); 该行代码中就是就是维护了 一个 ConcurrentHashMap 对象 ； 3.接下来就是一个 synchronized 同步块，把该类和该类的多个方法进行配对订阅
二、发送提交和订阅消费
提交事件到总线： EventBus.getDefault().post(object);
//将给定事件提交到事件总线
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get(); //1
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {//2
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);//3
}
} finally { //最终把状态都还原了
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}
//-------------------current Posting Thread State --------------------------
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};
//------------------Posting Thread State------------------------
/** For ThreadLocal, much faster to set (and get multiple values). */
final static class PostingThreadState {
final List<Object> eventQueue = new ArrayList<Object>(); //消息集合
boolean isPosting; //是否有发送
boolean isMainThread; //是否是主线程
Subscription subscription; //订阅关系
Object event; //具体发送的事件体
boolean canceled; //是否取消了
}1. PostingThreadState postingState = currentPostingThreadState.get() 该方法其实就是ThreadLocal对象(线程副本，为线程本身存储变量等信息)，而PostingThreadState就是线程副本内所存储JavaBean对象 (在此可以看出，该bean对象并没有get set封装)，从bean对象中获取到消息集合，并把当前post所要提交的消息保存在该集合中；
2. 使用 isposting 来判断是否发送过信息，然后进入下一步判断当前发送post方法执行的线程是否是主线程，设置发送状态，判断消息是否有效，while遍历
3. while在集合非空状态下，会不断遍历 postSingleEvent 方法，不断从集合中获取消息体和副本中数据进行处理，那么在往下查看有 postToSubscription(subscription, event, postingState.isMainThread) 这样的方法，它主要就是获取咱们标签中的value，根据不同的value 在不同的线程做不同的操作
//常用的四个标签
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING://当前线程执行
invokeSubscriber(subscription, event);
break;
case MAIN: //事件的消费会在UI线程。因此，不宜进行耗时操作，以免引起ANR
if (isMainThread) {
invokeSubscriber(subscription, event);
} else {
mainThreadPoster.enqueue(subscription, event);
}
break;
case BACKGROUND://背景线程，如果事件在UI线程产生，那么事件的消费会在单独的子线程中进行。否则，在同一个线程中消费。
if (isMainThread) {
backgroundPoster.enqueue(subscription, event);
} else {
invokeSubscriber(subscription, event);
}
break;
case ASYNC://异步执行，不管是否在UI线程产生事件，都会在单独的子线程中消费事件
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
//---------------------反射中的 方法执行---------------------------
void invokeSubscriber(Subscription subscription, Object event) {
try {
//通过反射获取到要执行的方法 subscription.subscriber，该方法的参数就是 通过 post要提交的消息
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.getDefault().unregister(this);
//每个待消费事件的class都会对应一个list集合
private final Map<Object, List<Class<?>>> typesBySubscriber;
//取消注册
public synchronized void unregister(Object subscriber) {
//获取该activity或fragment对应的注解类
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());
}
}在使用的时候只是简单导入eventbus jar，我们调用的时候只要简单的注册和配置注解标签即可，极大提供了开发效率，这就是提供框架的好处；另外重要的一点，就是学习文中的“注册”与“注销”的精神，程序做到了有始有终，在开辟了内存，在内存中完成业务，然后在view组件结束生命周期的时候把所占的内存、操作都结束了 ；初次解读，有问题的地方要指出，互相提高吧