EventBus3.0 study
概述
eventbus出来很久了，最近想用一下eventbus，自己对着一些博客撸了一个demo，发现竟然crash了，然后去看看源码发现3.0的eventbus有了很多改动。技术变化真快，得保持谦虚的态度，踏踏实实的学习。正好今天内部群里发了一个如何新技术的学习图，感觉挺好的
作为一个android入门小白还是要多学点。
基本概念
eventbus是一个是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求都可以通过EventBus实现，作为一个消息总线主要有三个组成部分：
- 事件（Event）
- 事件订阅者（Subscriber）
- 事件发布者（Publisher）
官方一张图可以很好地说明这三者关系
细细想来eventbus确实比android的回调函数要强很多，回调只能回到特定的类中，而Eventbus只要在某类中监听了某个消息，无论在哪个类中，只要有消息发出，监听类都会得到执行，而且比一些广播啥的更加高效。Eventbus主要功能是替代Intent,Handler,BroadCast（onreceive不能超过10s）在Fragment，Activity，Service，线程之间传递消息.优点是开销小，代码更优雅。以及将发送者和接收者解耦。不过也看到一些人说Eventbus用多了会使代码显得比较混乱。
如何使用
添加依赖 compile 'org.greenrobot:eventbus:3.0.0'
- 定义传递的数据结构
这是传递的一个载体，由于传递调用post需要一个object，因此定义的类也可以是一个空类
public class TestEvent {
private String mMsg;
public TestEvent(String msg) {
mMsg = msg;
}
public String getMsg() {
return mMsg;
}
}- 注册与注销
在需要接受消息的类中进行注册，我需要在MainActvity中接收消息，就在onCreate中注册
EventBus.getDefault().register(this);在onDestroy中注销
EventBus.getDefault().unregister(this);- 订阅函数
在注册的类中书写处理函数，以前都是说要以onEvent开头分为4个
1、onEvent
2、onEventMainThread
3、onEventBackgroundThread
4、onEventAsync
对应着在不同线程处理，其实3.0的eventbus抛弃了这种写法，你可以自定义函数名，但是，必须要在定义的函数上加上subscribe的注解，注解里面可以定义threadMode ，是否是sticky的，优先级，订阅函数是靠参数区分而不是靠函数名。比如这里就是在MAIN thread中
@Subscribe(threadMode = ThreadMode.MAIN)
public void doMain(TestEvent event) {
String msg = "onEventMainThread get the msg: \n" + event.getMsg();
tv_msg.setText(msg);
Log.d("thread main", Thread.currentThread().getName());
Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
}关于这几个参数这里介绍下：
- threadMode：
在EventBus中的观察者通常有四种线程模型，分别是PostThread（默认）、MainThread、BackgroundThread与Async。
PostThread：如果使用事件处理函数指定了线程模型为PostThread，那么该事件在哪个线程发布出来的，事件处理函数就会在这个线程中运行，也就是说发布事件和接收事件在同一个线程。在线程模型为PostThread的事件处理函数中尽量避免执行耗时操作，因为它会阻塞事件的传递，甚至有可能会引起ANR。
MainThread：如果使用事件处理函数指定了线程模型为MainThread，那么不论事件是在哪个线程中发布出来的，该事件处理函数都会在UI线程中执行。该方法可以用来更新UI，但是不能处理耗时操作。
BackgroundThread：如果使用事件处理函数指定了线程模型为BackgroundThread，那么如果事件是在UI线程中发布出来的，那么该事件处理函数就会在新的线程中运行，如果事件本来就是子线程中发布出来的，那么该事件处理函数直接在发布事件的线程中执行。在此事件处理函数中禁止进行UI更新操作。
Async：如果使用事件处理函数指定了线程模型为Async，那么无论事件在哪个线程发布，该事件处理函数都会在新建的子线程中执行。同样，此事件处理函数中禁止进行UI更新操作。
-sticky：
类似粘性广播那样,的粘性事件，简单来说就是发送该事件之后订阅该事件也可以收到订阅前的消息（只能收到最近的一条消息）
-priorty：
默认优先级为0，只有在同一个threadmode中优先级越大越先收到订阅事件。
- 发布函数
通过post或者postStcky来发布一条事件，如下，在TestActvity1中，点击按钮就发布一条事件
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_msgpost:
Log.d("thread send", Thread.currentThread().getName());
EventBus.getDefault().post(new TestEvent("testEvent1 msg send byTestAvtivity1"));
break;
}
}实例
代码下载传送门
这里做了俩个功能，MianActvity中只有俩个button 测试类名（btn_act1）、模拟广播的传递链(btn_act2),
MainActivty的订阅函数
@Subscribe(threadMode = ThreadMode.MAIN)
public void doMain(TestEvent event) {
String msg = "onEventMainThread get the msg: \n" + event.getMsg();
tv_msg.setText(msg);
Log.d("thread main", Thread.currentThread().getName());
Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
}
@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void doBack(TestEvent event) {
Log.d("thread back", Thread.currentThread().getName());
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void doAsync(TestEvent event) {
Log.d("thread async", Thread.currentThread().getName());
}
@Subscribe(threadMode = ThreadMode.POSTING)
public void dopost(TestEvent event) {
Log.d("thread post", Thread.currentThread().getName());
}在跳转到TestActvity1中点击按钮发布,
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_msgpost:
Log.d("thread send", Thread.currentThread().getName());
EventBus.getDefault().post(new TestEvent("testEvent1 msg send byTestAvtivity1"));
break;
}
}TestActivy1点击之后从打印中可看到如下日志
这也证明了订阅函数是靠参数区分而不是靠函数名 ，在MainActvity中订阅函数名称不同但是入参一样都是TestEvent。
btn_act2中发布函数中模拟发起网络请求
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_msgpost2:
EventBus.getDefault().post(new TestEvent2(" net request--send by TestAvtivity2"));
break;
}
}MainActivty的链式订阅函数
@Subscribe
public void doReceive(TestEvent2 event2) {
String msg = " receive the msg: \n" + event2.getMsg();
tv_msg.setText(msg);
EventBus.getDefault().post(new TestEvent3(" Net Datas"));
tv_step2.setText("request Net Data ing…… ");
}
@Subscribe
public void showNetData(TestEvent3 event3) {
String msg = "show data:\n" + event3.getMsg();
tv_step3.setText(msg);
}
这比回调或者广播高效多了
源码分析
- 注册
EventBus.getDefault().register(this); /** Convenience singleton for apps using a process-wide EventBus instance. */
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
public static EventBusBuilder builder() {
return new EventBusBuilder();
}在getdefault中使用双重枷锁，放止并发的产生，在register中去除了之前的4个参数的方法（Object subscriber, String methodName, boolean sticky, int priority）这些都移到了注解中，然后开始register方法
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}然后获取传入class对象subscriberMethodFinder.findSubscriberMethods(subscriberClass)获取到注解的订阅函数
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
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;
}
}这里根据是否产生索引来得到订阅方法名
分为是否产生索引？？这里没看懂，但是findUsingReflection和findUsingInfo里面都是通过一个while循环来找到具体的方法名
private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while (findState.clazz != null) {
findUsingReflectionInSingleClass(findState);
findState.moveToSuperclass();
}
return getMethodsAndRelease(findState);
}这里findUsingReflection和findUsingInfo都有findState.moveToSuperclass();这里EventBus对继承的父类也会进行查找注册函数，即子类注册一次即可，父类直接使用 @Subscribe来产生订阅函数即可。
findUsingReflectionInSingleClass(findState);是二者核心函数
private void findUsingReflectionInSingleClass(FindState findState) {
Method[] methods;
try {
// This is faster than getMethods, especially when subscribers are fat classes like Activities
methods = findState.clazz.getDeclaredMethods();
} catch (Throwable th) {
// Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
methods = findState.clazz.getMethods();
findState.skipSuperClasses = true;
}
for (Method method : methods) {
int modifiers = method.getModifiers();
// 事件处理方法必须为public，这里过滤掉所有非public方法
if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
Class<?>[] parameterTypes = method.getParameterTypes();
// 事件处理方法必须只有一个参数
if (parameterTypes.length == 1) {
Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
if (subscribeAnnotation != null) {
Class<?> eventType = parameterTypes[0];
if (findState.checkAdd(method, eventType)) {
ThreadMode threadMode = subscribeAnnotation.threadMode();
findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
}
}
} else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
// 如果某个方法加了@Subscribe注解，并且不是1个参数，则抛出EventBusException异常
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)) {
String methodName = method.getDeclaringClass().getName() + "." + method.getName();
throw new EventBusException(methodName +
" is a illegal @Subscribe method: must be public, non-static, and non-abstract");
}
}
}可以看出，这里该方法主要作用就是找出subscriberClass类以及subscriberClass的父类中所有的事件处理方法（添加了@Subscribe注解，访问修饰符为public并且只有一个参数）。值得注意的是：如果子类与父类中同时存在了相同事件处理函数，则父类中的不会被添加到subscriberMethods。
- post
/** Posts the given event to the event bus. */
public void post(Object event) {
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {
// 标识post的线程是否是主线程
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()) {
// 循环处理eventQueue中的event对象
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
// 重置postingState的一些标识信息
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}其中currentPostingThreadState是一个ThreadLocal类型，里面存储了PostingThreadState；
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
@Override
protected PostingThreadState initialValue() {
return new PostingThreadState();
}
};而PostingThreadState()中则包括post队列的一些信息
/** 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;
}
- 取消事件初注册
/** Unregisters the given subscriber from all event classes. */
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());
}
}这里所做的工作只是将注册的事件从Eventbus中移除
水平有限这里只是简单的分析了一下源码，了解大概而已。