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的丧心病狂解说