EventBus从入门到装逼，源码分析，手撸框架
文章目录
- EventBus是什么？有什么用
- EventBus简单使用
- EventBus原理解析
- 手撸EventBus框架
- EventBus 优化
1.EventBus是什么？有什么用
EventBus 是在 android 平台上基于订阅/发布模式（观察者模式）的事件处理机制，方便用于 android 组件内和组件之间的事件传递
简单的说法就是：一个事件或者通知在android的activity之间的传递方式（虽然片面，但是适合理解）
这就是EventBus？既然是组件之间的通信方式，android 本身就存在很多实现方式，比如 Intent，Broadcast，Handler ，那我为毛要使用EventBus？因为传统方式存在一些痛点，而EventBus刚好解决了它，因此它被广泛应用
传统方式缺点：
Intent 传递大数据时导致TransactionTooLargeException，Broadcast 接受事件之后无法指定运行线程，以及这些实现方式的繁琐，耦合
EventBus优点：
使用简单，可以指定接收事件的函数运行的线程，解耦，传递大量数据的Event时不会崩溃
这么神奇？赶紧看看 EventBus 的使用方式
2.EventBus简单使用
EventBus 使用方式很简单，在哪个对象中准备接受事件，就在那里注册 一下，然后写几个接收事件的方法，在页面销毁的时候解绑注册。准备工作做好之后，想在那里发送事件，直接post就行了。简单的一B
EventBus 是允许在任何对象中注册使用，也可以发送任何的事件。假设现在在Activity中点击按钮的时候发送一个事件，在当前的activity中接收事件，并且更新UI
备注：EventBus 事件传递允许在组件内和组件之间，本例子演示在组件内
2.1 准备接收事件的地方，注册一下
现在准备在Activity中接收事件，我们就在Activity的onCreate中注册EventBus
public class XActivity extends Activity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//注册
EventBus.getDefault().register(this);
}
}
注册方式很简单，通过 getDefault() 获取 EventBus 的单例，然后调用 register(Object obj) 完成注册
2.2 写一个接收事件的方法
在Activity中接收事件，编写一个接收事件的方法，指定运行线程为主线程
public class XActivity extends Activity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//注册
EventBus.getDefault().register(this);
}
/**
* 接收事件，通过注解的方式实现，指定运行线程为主线程
*
* @param event 事件对象
*/
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
//更新UI
button.setText(event);
}
}
接收事件的函数使用了注解，接收一个参数Object类型的对象。
看看 @Subscribe 注解支持那些属性
@Documented
@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Target({ElementType.METHOD})//作用于方法
public @interface Subscribe {
//运行线程
ThreadMode threadMode() default ThreadMode.POSTING;
//是否粘性事件
boolean sticky() default false;
//优先级
int priority() default 0;
}
通过代码可以了解到，@Subscribe 是作用于方法的的运行时注解，存在3个基础属性：
- threadMode() = 函数运行的线程
public enum ThreadMode {
/**
* 与发送事件同一个线程
* 注意：如果post在主线程，避免耗时操作
*/
POSTING,
/**
* 主线程
* 如果post在主线程，直接在主线程中运行，会阻塞发布线程
* 如果post在子线程，则事件排队等待传递，使用handler回调到主线程中
*/
MAIN,
/**
* 主线程-排队
* 不同于MAIN，此模式事件总是排队等待传递，不会阻塞发布线程
*/
MAIN_ORDERED,
/**
* 后台线程
* 如果post在子线程，则在post所在的线程执行
* 如果post是主线程，则使用单个后台线程按顺序执行
*/
BACKGROUND,
/**
* 异步线程
* 总是使用异步线程执行，通过线程池管理异步线程，不会阻塞发布线程和主线程
*/
ASYNC
}
- sticky() = 是否粘性事件（EventBus默认事件是非粘性的，可以通过这个属性指定，一般来说 EventBus 需要先注册然后才能接收事件，但是粘性事件特殊，可以先发送事件后注册，常用于 XActivity 跳转 YActivity 并且传递数据的场景 ）
- priority() = 事件优先级
2.3 发送事件
前面两个步骤已经完成了准备工作，现在可以在业务需要的地方发送事件，这里模拟点击按钮时发送事件
public class XActivity extends Activity {
private Button button;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//注册
EventBus.getDefault().register(this);
setContentView(R.layout.activity_x);
button = (Button) findViewById(R.id.btn_post);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//发送事件-->普通
EventBus.getDefault().post("normal-event");
//发送事件-->粘性
//EventBus.getDefault().postSticky("sticky-event");
}
});
}
/**
* 接收事件，通过注解的方式实现，指定运行线程为主线程
*
* @param event 事件对象
*/
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
//更新UI
button.setText(event);
}
}
我们看到发送事件也是非常简单，一样获取 EventBus 实例，调用 post(Object event) 发送 Object 类型事件。如果需要发送粘性事件则调用 postSticky(Object event)
2.4 解绑注册
在页面销毁，或者使用完成之后记得解绑注册，释放资源
public class XActivity extends Activity {
@Override
protected void onDestroy() {
super.onDestroy();
//解绑注册，释放资源
EventBus.getDefault().unregister(this);
}
}
Just so so 使用就这么简单。但是作为一名高级程序员我们怎么能仅仅满足于知道如何使用？我们想知道它的原理，想知道为什么EventBus传递大数据时不会崩溃，为什么可以如此方便的指定线程。
3.EventBus原理解析
到这里突然想帮大厂洗白一下，人都说大厂面试造航母，入职拧螺丝，在面试的时候总是喜欢问底层原理，框架结构等等。其实还是很有必要的，这都是在考察一个候选人的基础知识，就好比这即将要分析的EventBus原理，看官此刻能想到什么？你觉得它会是怎么实现的？
有些同学可能一脸懵逼，感觉很吊的一个框架，应该很难，什么头绪都没有；
有些同学可能就想到了一些基础，根据介绍中说EventBus基于观察者模式实现，又通过注解的方式实现接收事件的方法。
那么我们猜测：首先肯定跟注解相关，这个注解的知识你得了解吧！进而到注解的使用，注解怎么用？一般就是搭配反射呀，这反射你得会吧！进阶的还有apt，这apt你会吗？看看这就是为什么大厂要问你框架原理了，都是考察你的基础知识呀，这都不懂你怎么看框架源码？你怎么去BAT拿高薪？
OK，废话少说，现在我们一起看看 EventBus 的源码，了解一下这个框架的实现原理
首先我们通过使用步骤一步步看源码分析一下：
3.1 EventBus.getDefault().register(Object subscriber);
/**
* 注册对象
*/
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();//获取当前对象的class
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//获取当前类中使用@Subscribe注解的方法列表 ->> 分析点1
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);//遍历注解方法，订阅到当前对象 ->> 分析点2
}
}
}
分析点1： 通过反射获取 @Subscribe 注解的方法列表
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();//当前对象（如：XActivity）中使用@Subscribe注解的方法列表 缓存Map，key=当前对象，value=注解方法列表
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
//查看缓存中是否存在当前对象的注解方法列表，如果存在直接返回
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {
subscriberMethods = findUsingReflection(subscriberClass);//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
} else {
subscriberMethods = findUsingInfo(subscriberClass);//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
}
if (subscriberMethods.isEmpty()) {//如果没有找到注解方法，抛异常，这就是为什么在没有使用@Subscribe方法的类中尝试register会报错的原因
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
METHOD_CACHE.put(subscriberClass, subscriberMethods);//缓存Map，key=当前对象，value=注解方法列表
return subscriberMethods;
}
}
//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
//忽略代码
findUsingReflectionInSingleClass(findState);
}
//忽略无关紧要信息最终调用findUsingReflectionInSingleClass()
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
//忽略代码
findUsingReflectionInSingleClass(findState);
}
最终获取 @Subscribe 注解的方法列表
//在单个类中使用反射查找
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
methods = findState.clazz.getDeclaredMethods();//反射获取所有方法（public,private,protected,默认类型 ）
} catch (Throwable th) {
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
//遍历这个类中的所有方法，接下来无非就获取我们想要的方法（通过@Subscribe注解的方法），解析这个方法相关的信息（方法名称，方法修饰符，参数，以及注解相关的信息）
for (Method method : methods) {
int modifiers = method.getModifiers();//方法修饰符
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {//方法修饰类型必须是public=共有的 && 同时（不能抽象的，不能静态的，不能桥接的，不能合成的） （ MODIFIERS_IGNORE == Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC）
Class<?>[] parameterTypes = method.getParameterTypes();//方法参数类型数组（形参类型）
if (parameterTypes.length == 1) {//只有一个形参的方法
//获取注解@Subscribe相关信息
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {//注解不为空，说明此方法是@Subscribe注解的方法，也就是我们寻找的目标方法
Class<?> eventType = parameterTypes[0];//获取第一个形参的类型（如：Event.class,String.class）
if (findState.checkAdd(method, eventType)) {//校验是否参数是否满足条件，这个我们可以忽略吧
ThreadMode threadMode = subscribeAnnotation.threadMode();//获取注解上的信息线程模式（@Subscribe(threadMode = ThreadMode.MAIN)）
//获取其他注解信息（priority=优先级，sticky=是否粘性事件）然后构建SubscriberMethod对象保存到列表
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {//如果开启了严格验证，但是@Subscribe的方法参数超过1个，则抛异常（就是说如果开启了严格验证，@Subscribe注解的方法参数超过1个就会抛异常）
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException("@Subscribe method " + methodName +
"must have exactly 1 parameter but has " + parameterTypes.length);
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {//如果开启了严格校验，但是@Subscribe使用非public，或者static，或者abstract等修饰符，会报错
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}
我们可以看到这一步就是通过反射和注解相关的知识，获取注册对象中 使用 @Subscribe 注解的方法，然后将注解信息(运行线程，是否粘性，事件优先级)，方法(Method)，事件类型 封装成 SubscriberMethod 保存到 List 列表中，到这一步我们得到什么呢？
public class XActivity extends Activity {
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
@Subscribe(threadMode = ThreadMode.POSTING)
public void updateUI3(Object event) {
}
}
简单说，就是将注册对象（XActivity）中所有 @Subscribe 注解的方法信息都获取到了，并且封装在了一个list列表中，接下来就遍历这些方法信息，绑定到注册对象XActivity
分析点2
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);//遍历注解方法，订阅到当前对象
}
//绑定 SubscriberMethod 到 当前对象
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
/**
* 1.根据注解方法中的参数类型（event）作为key，保存所有参数是 event 的注解方法 的封装对象（包含注解方法所在的类）
* 例如：Activity1中存在注解方法 method1(String msg),method2(String msg) 那么Activity1和method1会打包成一个对象保存，Activity1和method2又会打包一个对象保存
*
* map.put("String.class", List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）) );
* map.put("Int.class", List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）) );
* 备注：这里的注册对象其实是注解方法和
*/
/**
* 重点对象
* 缓存集合 key = 事件对象类型（event.class），value = 所有参数是 event 的注解方法 的封装对象（包含注解方法所在的类）
* 可以理解为对于 String.class 类型的事件，有多个 Activity1，Activity2... 中存在接收的方法 （可以结合广播理解，一个 action，可以有多个广播接收器能够接收）
*/
private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
Class<?> eventType = subscriberMethod.eventType;//获取事件对象类型，也就是注解方法的参数类型
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//构建新的注册对象（理解为封装后的activity&Method对象）
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//根据事件对象类型为Key，获取缓存中的注册对象列表
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);//如果为空，添加到map
} else {
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;
}
}
/**
* 步骤1总结
*
* @Subscribe(threadMode = ThreadMode.MAIN)
* public void updateUI(String event) {
* }
*
* 到这一步为止，会根据 String.class 作为key 保存所有方法参数为String的封装对象（理解为 List(Subscription（Activity1&m1）,Subscription（Activity1&m2）,Subscription（Activity2&m1）)）
* 有什么作用呢？等下 post(String event) 的时候就可以根据这个 String.class 作为key找到 所有的已经注册的对象，然后挨个调用这些对象中的 @Subscribe 方法
*/
/**
* 2.根据当前注册对象（Activity）作为key，保存所有事件类型。形成一个map
* map.put("Activity1",List(String.class,Int.class..));
* map.put("Activity2",List(String.class,Int.class..));
*/
/**
* 重点对象
* 缓存集合 key = 当前注册对象，value = 事件对象类型列表
* 可以理解为在 Activity1 中存在多个注解方法，他们的事件类型为 String.class ，Int.class
*/
private final Map<Object, List<Class<?>>> typesBySubscriber;
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);//添加事件类型
/**
* 步骤2总结
*
* 到这一步为止，会根据当前注册对象 Activity 作为key 保存本类中所有注解方法的事件类型（也是方法参数类型）
*
* 有什么作用呢？
* 1.用于查询是否已经注册了当前对象 isRegistered(Object subscriber){ return typesBySubscriber.containsKey(subscriber); }
* 2.解绑注册 unregister(Object subscriber) 的时候可以找到所有的事件类型，（结合 subscriptionsByEventType ）然后再根据事件找到 已经注册对象的列表，移除当前注册的对象
*/
/**
* 3.判断当前注册对象中的注解方法是否为粘性事件，如果粘性事件，从粘性事件缓存中取出粘性事件相关的信息
*/
/**
* 重点对象
* 缓存集合 key = 事件对象类型，value = Object（事件）
* 粘性事件单独存在一个Map集合中，这也是为什么可以先发送粘性事件，然后在注册接收，因为它存放在缓存map中，只要不清除，它就一直在
* map.put("String.class", Object 粘性事件1 );
* map.put("String.class", Object 粘性事件2 );
* map.put("Int.class", Object 粘性事件1 );
* map.put("Int.class", Object 粘性事件2 );
*/
private final Map<Class<?>, Object> stickyEvents;
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);//根据事件类型在粘性map中查找粘性事件
checkPostStickyEventToSubscription(newSubscription, stickyEvent);//调用post事件，调用对应的注解方法，使得注解方法能够接收之前发送的粘性事件
}
}
}
通过分析点2，我们可以知道，注册过程中，就是将获取到的注解方法列表 挨个遍历，然后构造了2个重要的map，将数据保存在map中，需要使用的时候再去取出来。
分析点1和分析点2 构成了 register(Object subscriber) 方法，此方法主要内容
1.获取注册对象中通过 @Subscribe 注解的方法，保存在list列表
2.遍历注解方法列表，逐个绑定到当前对象
2.1 根据注解方法事件对象类型，构建map
class Activity1{
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
class Activity2{
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI)));
map.put("Int.class", List(Subscription(Activity1&updateUI2),Subscription(Activity2&updateUI2)));
如上述伪代码，Activity1 和 Activity2 中都使用 @Subscribe 注解接收事件的方法，事件的类型为String，int
那么根据事件对象类型作为 key 保存 map 可以得到：map.put("Stirng.class", List(Subscription(Activity1&updateUI),Subscription(Activity2&updateUI))); 表示多个Activity绑定了事件对象类型为 String 的事件。 构建这个map有何作用？ 因为后续 post（事件）时要根据事件类型发送给所有已经注册该事件类型的对象（Activity）中的注解方法 (updateUI(String event))
2.2 根据注册对象（Activity）保存当前对象中存在的事件类型，构建map
class Activity1{
@Subscribe(threadMode = ThreadMode.MAIN)
public void updateUI(String event) {
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void updateUI2(int event) {
}
}
map.put("Activity1", List(String.class,Int.class..));
如上述伪代码，在注册对象（这里假设是Activity）中将所有接收事件的事件类型保存起来，可以得到：map.put("Activity1", List(String.class,Int.class..)); 表示 Acticity1 对象中存在多种类型的事件。有何作用？1.用于查询是否已经注册了当前对象 2.为解绑注册，释放资源做支撑（解绑注册后面详细分析）
2.3 如果当前注解方法接收的事件是粘性事件，则根据当前方法的参数类型（也就是事件类型）从粘性事件map缓存中（postSticky时保存）获取粘性事件信息，如果存在则执行当前注解方法（实现延迟响应事件的原理）
可以看到 register() 算是一个重头戏，主要是保存一些数据，为后续post发送事件做一些铺垫作用。那接下来就看看 post 方法的源码
3.2 EventBus.getDefault().post(Object event);
发送事件，可以是任意类型的事件
//发送事件
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();//根据不同Thread区分保存对象
List<Object> eventQueue = postingState.eventQueue;//事件列表
eventQueue.add(event);
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
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;
}
}
}
//发送单一事件
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();//事件对象class
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);//发送事件
}
if (!subscriptionFound) {//未找到订阅对象
if (logNoSubscriberMessages) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));//未找到订阅对象，发送NoSubscriberEvent
}
}
}
//根据事件类型发送找到注册对象，然后逐个发送事件
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);//获取注册时添加的注册对象，也就是寻找绑定eventClass的activity集合，可以看到这里依赖于注册方法准备的数据
}
if (subscriptions != null && !subscriptions.isEmpty()) {//循环所有注册对象（例如：activity1,activity2..）
for (Subscription subscription : subscriptions) {
postingState.event = event;
postingState.subscription = subscription;
boolean aborted = false;
try {
postToSubscription(subscription, event, postingState.isMainThread);//发送事件到已注册的对象（某个activity）
aborted = postingState.canceled;
} finally {
postingState.event = null;
postingState.subscription = null;
postingState.canceled = false;
}
if (aborted) {
break;
}
}
return true;
}
return false;
}
//发送事件线程处理，队列处理
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
switch (subscription.subscriberMethod.threadMode) {
case POSTING://与发送事件同一个线程,如果post在主线程，避免耗时操作
invokeSubscriber(subscription, event);//直接反射调用方法
break;
case MAIN://主线程
if (isMainThread) {//如果post在主线程，直接在主线程中运行，会阻塞发布线程
invokeSubscriber(subscription, event);
} else {//如果post在子线程，则事件排队等待传递，使用handler回调到主线程中
mainThreadPoster.enqueue(subscription, event);
}
break;
case MAIN_ORDERED://主线程-排队
/**
* 这里就有点尴尬了，前面根据 ThreadMode 类的解释是：不同于MAIN，此模式事件总是排队等待传递，不会阻塞发布线程
* 但这里的实现并不是一定方式队列中。不过源码中官方自己备注了技术上实现不正确，未按照 ThreadMode 定义的思想来实现，所以我们就不管它了
*/
if (mainThreadPoster != null) {
mainThreadPoster.enqueue(subscription, event);//事件排队等待传递，不会阻塞发布线程
} else {
// temporary: technically not correct as poster not decoupled from subscriber
// 临时：技术上不正确，未与post线程分离
invokeSubscriber(subscription, event);
}
break;
case BACKGROUND://后台线程
if (isMainThread) {//如果post是主线程，则使用单个后台线程按顺序执行
backgroundPoster.enqueue(subscription, event);
} else {//如果post在子线程，则在post所在的线程执行
invokeSubscriber(subscription, event);
}
break;
case ASYNC://异步线程,总是使用异步线程执行，通过线程池管理异步线程，不会阻塞发布线程和主线程
asyncPoster.enqueue(subscription, event);
break;
default:
throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
}
}
//最终执行方法，通过反射调用 method.invoke(方法所在对象,方法参数)
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);
}
}
post 方法代码很简单，跟着注释走主要路线就行，首先通过事件类型，找到已经注册的列表，（注册列表在每次注册的时候添加），找到注册列表之后挨个发送当前事件，怎么发送当前事件？找到注册对象的目标method，根据method指定的运行线程，按需要做一些线程切换的操作，然后通过反射调用 method.invoke(方法所在对象,方法参数)，就这么简单。
再看看发送粘性事件是怎么处理的
//发送粘性事件
public void postSticky(Object event) {
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);//将粘性事件保存到缓存map中
}
// 调用post方法
post(event);
}
so easy. 粘性事件和普通事件相比，就多了一步将粘性事件保存到缓存 map 中，原来粘性事件的原理这么简单，发送的时候保存到缓存map中，延时（需要时）再取，实现了可以先发送事件，后注册的效果。
3.3 EventBus.getDefault().unregister(Object subscriber);
//解绑注册，释放资源等
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 {
logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
}
}
//根据事件类型解绑已注册对象
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--;
}
}
}
}
解绑注册也是比较简单的，首先通过当前对象找到本类中所有的事件类型，再根据某个事件类型找到已经注册该事件的对象列表（如：activity1，activity2…），然后根据比较当前对象是否存在列表中，如果存在，从列表中移除，释放资源
以上便是EventBus的源码解析，结合注释，相信能够看懂它的原理思想，由于分析的时候需要抓住主线不向外扩散，忽略了一些代码，看客最好根据文章打开源码对照着看看，加深印象。文章基于 EventBus 3.1.1
看完源码来讨论几个问题：
1.为什么EventBus传递大数据时不会崩溃？
分析：
Intent 方式实际上底层parcel对象在不同activity直接传递过程中保存在一个叫做“ Binder transaction buffe ”的缓冲区，并且这个缓冲区大小有限制，不能超过1M。
EventBus 不存在将数据放在什么缓冲区中，普通事件直接拿到事件对象，找到需要调用的方法直接调用即可，简单的方法参数传递； 而粘性事件，将数据缓存在内存中，保存在map，除非是内存爆炸，不然是没有大小限制的说法。因此说EventBus可以传递大数据
2.EventBus如何指定接收事件方法运行的线程？
分析：
EventBus 通过注解的方式指定接收事件的运行线程，在注册的时候将注解信息保存起来，当post事件的时候拿到注册时保存的注解信息（运行线程），通过不同的 ThreadMode 做不同的处理，如开启工作线程执行接收事件的方法，或者通过handler方式将事件运行在主线程中，以此达到指定线程运行方法的目的
嗯，感觉良好，熟练使用了，源码分析也会了，常见面试问题也知道怎么回答了，如果这时候面试官突然问你：能自己手写一个EventBus框架吗？
What the X ? 好不容易分析完了源码，你还想给你手撸一个框架出来？没错，就是手撸一个EventBus框架！不要虚，源码分析出来了，思路已经知道了，手撸框架也不过如此，来，跟着痞子哥干它！
4.手撸EventBus框架
当然，EventBus框架还是相对比较完善的，这里说的手撸框架，是实现简易版本的，实现主要的功能，通过自己动手实现，深入理解框架思想，加深理解。
我们暂且按照EventBus提供的各个几个接口来实现主要核心逻辑
首先就是 REventBus
/**
* 简易版本EventBus
*/
public class REventBus {
static volatile REventBus mInstance;
private REventBus() {
}
/**
* 单例实现，双重校验
*
* @return
*/
public static REventBus getDefault() {
if (mInstance == null) {
synchronized (REventBus.class) {
if (mInstance == null) {
mInstance = new REventBus();
}
}
}
return mInstance;
}
/**
* 注册对象
*
* @param subscriber 订阅对象
*/
public void register(Object subscriber) {
}
/**
* 解绑注册，释放资源
*
* @param subscriber 订阅对象
*/
public void unregister(Object subscriber) {
}
/**
* 发送事件
*
* @param event 事件
*/
public void post(Object event) {
}
/**
* 发送粘性事件
*
* @param event 事件
*/
public void postSticky(Object event) {
}
/**
* 某对象是否已经订阅
*
* @param subscriber 订阅对象
* @return
*/
public boolean isRegistered(Object subscriber) {
return false;
}
}
自定义注解 (这里暂时欠一篇关于注解的文章，后续写完补充)
@Retention(RetentionPolicy.RUNTIME)//运行注解
@Target({ElementType.METHOD})//作用于方法
public @interface Subscribe {
/**
* 事件运行线程
*/
ThreadMode threadMode() default ThreadMode.POSTING;
/**
* 是否粘性事件
*/
boolean sticky() default false;
}
ThreadMode
public enum ThreadMode {
/**
* 调用线程
*/
POSTING,
/**
* 主线程
*/
MAIN
}
以上就是EventBus基础的类，在REventBus中已经定好了基础的API，那么现在我们来一步步完善它
4.1 手撸EventBus框架–>register(Object subscriber)
回忆 EventBus ->> register() 原理
- 获取订阅对象中订阅方法（注解方法）的信息，并且封装成对象
SubscriberMethod
//订阅方法封装的对象
class SubscriberMethod {
Object subscriber;//订阅者
Method method;//订阅方法
ThreadMode threadMode;//订阅方法运行线程
Class<?> eventType;//事件类型class
boolean sticky;//是否粘性
public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
this.subscriber = subscriber;
this.method = method;
this.eventType = eventType;
this.threadMode = threadMode;
this.sticky = sticky;
}
}
获取订阅对象中的注解方法（订阅方法），返回的是一个列表（可能一个类中有多个注解方法嘛）
/**
* 获取当前对象中注解方法信息(列表)
*
* @param subscriber
* @return
*/
private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
List<SubscriberMethod> list = new ArrayList<>();
Class<?> subscriberClass = subscriber.getClass();//注册对象的class
Method[] methods = subscriberClass.getDeclaredMethods();//获取所有修饰类型的方法
for (Method method : methods) {
Subscribe subscribe = method.getAnnotation(Subscribe.class);//获取方法注解信息
if (subscribe == null) {//如果为空，表示此方法不是注解方法
continue;
}
Class<?>[] types = method.getParameterTypes();//获取方法参数列表class，注意是class，比如int->Int.class
if (types.length != 1) {//这里只接受一个参数的方法（参照EventBus）
throw new RuntimeException("REventBus 只接受一个参数!");
}
ThreadMode threadMode = subscribe.threadMode();//获取注解信息 -> ThreadMode (第一次接触注解的同学是不是恍然大悟，真TM简单)
boolean sticky = subscribe.sticky();//获取注解信息 -> sticky
//构建 SubscriberMethod 封装注解信息，方法参数，方法对象
SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
list.add(subscriberMethod);//添加到列表
}
return list;
}
- 将订阅方法绑定到订阅对象。当订阅方式是粘性时特殊处理，从粘性事件集合中得到事件，执行对应方法
//某事件对象的 订阅者列表 集合
private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
//某订阅者的 事件列表 集合
private Map<Object, List<Class<?>>> subscriberEventMap;
//粘性事件集合 key = 事件.class
private Map<Class<?>, Object> stickyEventMap;
/**
* 将 订阅方法 与 订阅对象 绑定
*
* @param subscriber 订阅对象
* @param subscriberMethod 订阅方法
*/
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//获取 某事件对象的 订阅者列表 集合
if (subscriberMethods == null) {
subscriberMethods = new ArrayList<>();
subscriberMethodMap.put(eventType, subscriberMethods);
}
subscriberMethods.add(subscriberMethod);
List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
subscriberEventMap.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {//粘性事件方法
Object eventSticky = stickyEventMap.get(eventType);//粘性事件对象
if (eventSticky != null) {//存在粘性事件，调用当前方法
postEvent(subscriberMethod, eventSticky);
}
}
}
综述，register方法为：
/**
* 注册对象
*
* @param subscriber 订阅对象
*/
public void register(Object subscriber) {
List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//获取订阅者中的注解方法
if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容错
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
subscribe(subscriber, subscriberMethod);//绑定订阅对象和订阅方法
}
}
4.2 手撸EventBus框架–>post(Object event)
回忆post原理：
获取所有事件为 event 的订阅方法，然后逐个发送事件，发送事件的原理是通过反射实现方法的调用，同时根据指定的线程模式做线程切换
/**
* 发送事件
*
* @param event 事件
*/
public void post(Object event) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//获取某事件的所有订阅者
if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容错
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
postEvent(subscriberMethod, event);//发送事件
}
}
/**
* 发送事件
*
* @param subscriberMethod 订阅方法封装的对象
* @param event 事件（方法参数）
*/
private void postEvent(SubscriberMethod subscriberMethod, Object event) {
Object subscriber = subscriberMethod.subscriber;//订阅者
ThreadMode threadMode = subscriberMethod.threadMode;//订阅方法的执行线程
Method method = subscriberMethod.method;//订阅方法
switch (threadMode) {
case POSTING://post线程
invokeMethod(subscriber, method, event);
break;
case MAIN://主线程
//通过handler实现主线程调用方法
Object[] objects = new Object[]{subscriber, method, event};
mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
break;
}
}
/**
* 通过反射执行方法
*
* @param subscriber 方法所在对象
* @param method 方法对象
* @param event 方法参数
*/
private void invokeMethod(Object subscriber, Method method, Object event) {
try {
method.invoke(subscriber, event);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/**
* Handler
*/
class MainHandler extends Handler {
public MainHandler() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Object[] obj = (Object[]) msg.obj;
Object subscriber = obj[0];//类对象
Method method = (Method) obj[1];//方法
Object event = obj[2];//方法参数
//反射执行方法
invokeMethod(subscriber, method, event);
}
}
4.3 手撸EventBus框架–>unregister(Object subscriber)
回忆解绑注册原理：
通过当前对象获取 该订阅者的 事件列表，在订阅者列表中找到当前订阅对象，移除它。然后再清空当前订阅者的 事件列表
/**
* 解绑注册，释放资源
*
* @param subscriber 订阅对象
*/
public void unregister(Object subscriber) {
List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
if (eventClass == null || eventClass.isEmpty()) return;//容错
for (Class<?> clazz : eventClass) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//获取 某事件对象的 订阅者列表 集合
for (int i = 0; i < subscriberMethodList.size(); i++) {
if (subscriberMethodList.get(i).subscriber == subscriber) {//在订阅者列表中找到当前订阅对象
subscriberMethodList.remove(i);//移除它
}
}
}
subscriberEventMap.remove(subscriber);//移除当前订阅者的 事件列表
}
REventBus一览
/**
* 简易版本EventBus
*/
public class REventBus {
static volatile REventBus mInstance;
//主线程Handler
private MainHandler mainHandler;
//某事件对象的 订阅者列表 集合
private Map<Class<?>, List<SubscriberMethod>> subscriberMethodMap;
//某订阅者的 事件列表 集合
private Map<Object, List<Class<?>>> subscriberEventMap;
//粘性事件集合 key = 事件.class
private Map<Class<?>, Object> stickyEventMap;
private REventBus() {
subscriberMethodMap = new HashMap<>();
subscriberEventMap = new HashMap<>();
stickyEventMap = new HashMap<>();
mainHandler = new MainHandler();
}
/**
* 单例实现，双重校验
*
* @return
*/
public static REventBus getDefault() {
if (mInstance == null) {
synchronized (REventBus.class) {
if (mInstance == null) {
mInstance = new REventBus();
}
}
}
return mInstance;
}
/**
* 注册对象
*
* @param subscriber 订阅对象
*/
public void register(Object subscriber) {
List<SubscriberMethod> subscriberMethodList = getSubscriberMethod(subscriber);//获取订阅者中的注解方法
if (subscriberMethodList == null || subscriberMethodList.isEmpty()) return;//容错
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
subscribe(subscriber, subscriberMethod);//绑定订阅对象和订阅方法
}
}
/**
* 获取当前对象中注解方法信息(列表)
*
* @param subscriber
* @return
*/
private List<SubscriberMethod> getSubscriberMethod(Object subscriber) {
List<SubscriberMethod> list = new ArrayList<>();
Class<?> subscriberClass = subscriber.getClass();//注册对象的class
Method[] methods = subscriberClass.getDeclaredMethods();//获取所有修饰类型的方法
for (Method method : methods) {
Subscribe subscribe = method.getAnnotation(Subscribe.class);//获取方法注解信息
if (subscribe == null) {//如果为空，表示此方法不是注解方法
continue;
}
Class<?>[] types = method.getParameterTypes();//获取方法参数列表class，注意是class，比如int->Int.class
if (types.length != 1) {//这里只接受一个参数的方法（参照EventBus）
throw new RuntimeException("REventBus 只接受一个参数!");
}
ThreadMode threadMode = subscribe.threadMode();//获取注解信息 -> ThreadMode (第一次接触注解的同学是不是恍然大悟，真TM简单)
boolean sticky = subscribe.sticky();//获取注解信息 -> sticky
//构建 SubscriberMethod 封装注解信息，方法参数，方法对象
SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, types[0], threadMode, sticky);
list.add(subscriberMethod);//添加到列表
}
return list;
}
/**
* 将 订阅方法 与 订阅对象 绑定
*
* @param subscriber 订阅对象
* @param subscriberMethod 订阅方法
*/
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
List<SubscriberMethod> subscriberMethods = subscriberMethodMap.get(eventType);//获取 某事件对象的 订阅者列表 集合
if (subscriberMethods == null) {
subscriberMethods = new ArrayList<>();
subscriberMethodMap.put(eventType, subscriberMethods);
}
subscriberMethods.add(subscriberMethod);
List<Class<?>> subscribedEvents = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
subscriberEventMap.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {//粘性事件方法
Object eventSticky = stickyEventMap.get(eventType);//粘性事件对象
if (eventSticky != null) {//存在粘性事件，调用当前方法
postEvent(subscriberMethod, eventSticky);
}
}
}
/**
* 解绑注册，释放资源
*
* @param subscriber 订阅对象
*/
public void unregister(Object subscriber) {
List<Class<?>> eventClass = subscriberEventMap.get(subscriber);//获取 某订阅者的 事件列表 集合
if (eventClass == null || eventClass.isEmpty()) return;//容错
for (Class<?> clazz : eventClass) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(clazz);//获取 某事件对象的 订阅者列表 集合
for (int i = 0; i < subscriberMethodList.size(); i++) {
if (subscriberMethodList.get(i).subscriber == subscriber) {//在订阅者列表中找到当前订阅对象
subscriberMethodList.remove(i);//移除它
}
}
}
subscriberEventMap.remove(subscriber);//移除当前订阅者的 事件列表
}
/**
* 发送事件
*
* @param event 事件
*/
public void post(Object event) {
List<SubscriberMethod> subscriberMethodList = subscriberMethodMap.get(event.getClass());//获取某事件的所有订阅者
if (subscriberMethodList == null && subscriberMethodList.isEmpty()) return;//容错
for (SubscriberMethod subscriberMethod : subscriberMethodList) {
postEvent(subscriberMethod, event);//发送事件
}
}
/**
* 发送粘性事件
*
* @param event 事件
*/
public void postSticky(Object event) {
//保存粘性事件
stickyEventMap.put(event.getClass(), event);
//调用post
post(event);
}
/**
* 发送事件
*
* @param subscriberMethod 订阅方法封装的对象
* @param event 事件（方法参数）
*/
private void postEvent(SubscriberMethod subscriberMethod, Object event) {
Object subscriber = subscriberMethod.subscriber;//订阅者
ThreadMode threadMode = subscriberMethod.threadMode;//订阅方法的执行线程
Method method = subscriberMethod.method;//订阅方法
switch (threadMode) {
case POSTING://post线程
invokeMethod(subscriber, method, event);
break;
case MAIN://主线程
//通过handler实现主线程调用方法
Object[] objects = new Object[]{subscriber, method, event};
mainHandler.sendMessage(mainHandler.obtainMessage(1, objects));
break;
}
}
/**
* 通过反射执行方法
*
* @param subscriber 方法所在对象
* @param method 方法对象
* @param event 方法参数
*/
private void invokeMethod(Object subscriber, Method method, Object event) {
try {
method.invoke(subscriber, event);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/**
* 某对象是否已经订阅
*
* @param subscriber 订阅对象
* @return
*/
public boolean isRegistered(Object subscriber) {
return subscriberEventMap.containsKey(subscriber);
}
/**
* 封装订阅方法
*/
class SubscriberMethod {
Object subscriber;//订阅者
Method method;//订阅方法
ThreadMode threadMode;//订阅方法运行线程
Class<?> eventType;//事件类型class
boolean sticky;//是否粘性
public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, ThreadMode threadMode, boolean sticky) {
this.subscriber = subscriber;
this.method = method;
this.eventType = eventType;
this.threadMode = threadMode;
this.sticky = sticky;
}
}
/**
* Handler
*/
class MainHandler extends Handler {
public MainHandler() {
super(Looper.getMainLooper());
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Object[] obj = (Object[]) msg.obj;
Object subscriber = obj[0];//类对象
Method method = (Method) obj[1];//方法
Object event = obj[2];//方法参数
//反射执行方法
invokeMethod(subscriber, method, event);
}
}
}
这里明确说明，这个类只是用于分析和加深理解EventBus的框架原理，虽然功能是可以跑通的，但是不要直接应用到项目中，毕竟是简易版本，还有很多地方需要完善和容错
5.EventBus 优化
当我们自信满满的撸完EventBus框架之后，面试官又问了一个问题：EventBus 是否存在性能问题？它使用反射实现，是否还可以再优化一下？
啊~西八！这offer我不要了，这不是逼死人嘛！ 不要offer了？怎么可能，我不但要了这offer，我还想提个价格
首先，反射调用和直接调用到底性能差多少？很多人一听到反射就说性能不好，一棒子打死了，但是究竟差多少呢？有什么数字指标拿出来说话呢？在这里再欠一篇文章，后续找时间分析一下写篇文章。
反射是肯定存在性能问题，差多少暂时不讨论，如果不要使用反射是不是就可以提升一下呢？如果我们能通过直接调用方法的方式，来避免反射调用方法带来的性能问题，是不是就可以提升性能了呀。
如果我们知道即将调用的方法长什么样，给他提前写好，而不是运行时反射调用，就可以解决这个问题，而提前写好方法的实现方式也是有的，那就是apt！在编译时就创建”方法副本“提供代码调用。
由于篇幅原因，这里又欠了一篇关于apt的使用文章！
一篇文章读下来，就算没有完全掌握，起码知道有几个知识点需要去学习一下：
Java基础-反射
注解
设计模式->单例
apt技术
源码中忽略掉的ThreadLocal
反射相关的用法直接写了一篇博客，剩下的几个内容暂时欠着，后续各自写一篇文章补上！