EventBus从入门到装逼，源码分析，手撸框架
Posted Ruffian-痞子
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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<SubscriberMethod> subscriberMethods 列表中，到这一步我们得到什么呢？
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)
Java框架型项目从入门到装逼第一节 - Spring框架 IOC的丧心病狂解说