Android系统之EventBus用法及源码分析

最新推荐文章于 2024-03-19 15:46:34 发布

暖阳55555

最新推荐文章于 2024-03-19 15:46:34 发布

阅读量513

点赞数

分类专栏： Android 文章标签： android EventBus

本文链接：https://blog.csdn.net/litao55555/article/details/120396997

版权

Android 专栏收录该内容

23 篇文章 5 订阅

订阅专栏

1. EventBus简介

EventBus是一款在Android开发中使用的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分开，简化了组件之间的通信，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。
使用简单、效率高、体积小！下边是官方的 EventBus 原理图：
在这里插入图片描述

2. EventBus使用方法

2.1 使用步骤

a. 添加依赖库
在项目对应的build.gradle文件添加

compile 'org.greenrobot:eventbus:3.0.0'

b. 注册

EventBus.getDefault().register(this);

c. 注销

EventBus.getDefault().unregister(this);

d. 构造发送事件类

public class MyEvent {
    private int mMsg;
    public MyEvent(int msg) {
        mMsg = msg;
    }
    public int getMsg(){
        return mMsg;
    }
}

e. 发布事件

EventBus.getDefault().post(new MyEvent(time));

f. 接收事件

@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(MyEvent event){
	progressBar.setProgress(event.getMsg());
}

onEvent为Subscriber，MyEvent为监听的事件类型

2.2 使用示例

实现一个进度条，线程A发送进度百分比，线程B接收进度百分比并显示
参考：https://blog.csdn.net/bzlj2912009596/article/details/81664984
a. build.gradle

dependencies {
	//1. 添加依赖库
    compile 'org.greenrobot:eventbus:3.0.0'
}

b. activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.wgh.eventbusdemo.MainActivity"
    android:orientation="vertical">
 
    <ProgressBar
        android:id="@+id/progressbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="150dp"
        android:max="100"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"/>
    <Button
        android:id="@+id/button"
        android:layout_marginTop="10dp"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="开始下载"/>
</LinearLayout>

c. MainActivity.java

package com.example.wgh.eventbusdemo;
 
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.ProgressBar;
 
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
 
 
public class MainActivity extends Activity {
 
    public ProgressBar progressBar = null;
    public int time = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while (time<100){
                            time += 15;
							//4. 发送消息
                            EventBus.getDefault().post(new MyEvent(time));
                            try {
                                Thread.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }).start();
            }
        });
        progressBar = (ProgressBar) findViewById(R.id.progressbar);
		//2. 注册EventBus
        EventBus.getDefault().register(this);
    }
 
    @Override
    protected void onDestroy() {
        super.onDestroy();
		//6. 注销EventBus
        EventBus.getDefault().unregister(this);
    }
	//5. 接收消息
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onEvent(MyEvent event){
        progressBar.setProgress(event.getMsg());
    }
}

d. MyEvent.java

//3. 构造发送消息类
public class MyEvent {
    private int mMsg;
    public MyEvent(int msg) {
        mMsg = msg;
    }
    public int getMsg(){
        return mMsg;
    }
}

注意：发送的消息和接收消息的函数参数必须一致，否则接收消息的函数无法接收到消息
例如发送消息：EventBus.getDefault().post(new MyEvent1(time));时，只有消息函数1能接收到消息。
接收消息函数1：public void onEvent(MyEvent1 event){…}
接收消息函数2：public void onEvent(MyEvent2 event){…}

3. EventBus原理

3.1 Subscribe注解

EventBus3.0 开始用Subscribe注解配置事件订阅方法，不再使用方法名了

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    // 指定事件订阅方法的线程模式，即在那个线程执行事件订阅方法处理事件，默认为POSTING
    ThreadMode threadMode() default ThreadMode.POSTING;
    // 是否支持粘性事件，默认为false
    boolean sticky() default false;
    // 指定事件订阅方法的优先级，默认为0，如果多个事件订阅方法可以接收相同事件的，则优先级高的先接收到事件
    int priority() default 0;
}

ThreadMode.POSTING，默认的线程模式，在那个线程发送事件就在对应线程处理事件，避免了线程切换，效率高。
ThreadMode.MAIN，如在主线程（UI线程）发送事件，则直接在主线程处理事件；如果在子线程发送事件，则先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。
ThreadMode.MAIN_ORDERED，无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。
ThreadMode.BACKGROUND，如果在主线程发送事件，则先将事件入队列，然后通过线程池依次处理事件；如果在子线程发送事件，则直接在发送事件的线程处理事件。
ThreadMode.ASYNC，无论在那个线程发送事件，都将事件入队列，然后通过线程池处理。

3.2 Subscribers和Events之间的关系

注册的Subscriber将会保存到subscriptionsByEventType和typesBySubscriber
a. subscriptionsByEventType
在这里插入图片描述

subscriptionsByEventType是一个HashMap，key为注册Subscriber监听事件的事件类型eventType，value为所有监听相同事件类型为eventType的Subscriber
b. typesBySubscriber
在这里插入图片描述

typesBySubscriber是一个HashMap，key为注册Subscriber的当前类MainActivity，value为当前类包含的所有类型Subscriber

3.3 粘性事件

一般情况，我们使用EventBus都是准备好订阅事件的方法，然后注册事件，最后在发送事件，即要先有事件的接收者。但粘性事件却恰恰相反，我们可以先发送事件，然后再准备订阅事件的方法、注册事件，这种事件即为粘性事件。
即一般事件先注册监听某事件的Subscriber，再发送此事件；但是粘性事件是先发送某事件，再注册该事件的Subscriber

4. EventBus源码分析

4.1 register注册事件

EventBus.getDefault().register(this);

源码分析：

EventBus.java (frameworks\base\packages\systemui\src\com\android\systemui\recents\events)	39817	2017/8/25
public class EventBus extends BroadcastReceiver {
    public static EventBus getDefault() {
        if (sDefaultBus == null)
        synchronized (sLock) {
            if (sDefaultBus == null) {
                if (DEBUG_TRACE_ALL) {
                    logWithPid("New EventBus");
                }
                sDefaultBus = new EventBus(Looper.getMainLooper());
            }
        }
        return sDefaultBus;
    }
}

public void register(Object subscriber) {
	Class<?> subscriberClass = subscriber.getClass();	//获取当前注册Subscriber的类，此处为MainActivity
	List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);	//获取当前类中的所有注册事件的函数，即获取所有Subscribe注解的函数
	synchronized (this) {
		for (SubscriberMethod subscriberMethod : subscriberMethods) {
			subscribe(subscriber, subscriberMethod);	//循环注册所有的事件
		}
	}
}

subscriber为MainActivity，subscriberMethods为保存了当前注册类MainActivity及其父类中所有订阅事件的方法的集合

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
	Class<?> eventType = subscriberMethod.eventType;	//获取当前注册事件的参数类型，根据参数类型区分不同的事件
	Subscription newSubscription = new Subscription(subscriber, subscriberMethod);	//1. 创建当前监听事件对应的Subscription
	CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);	//1. 重点：subscriptionsByEventType是一个HashMap，key为eventType事件类型，value为所有监听相同事件类型的函数
	if (subscriptions == null) {
		subscriptions = new CopyOnWriteArrayList<>();
		subscriptionsByEventType.put(eventType, subscriptions);
	}
	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);		//1. 将注册的Subscriber保存到subscriptionsByEventType
			break;
		}
	}
	//-------------------------------------------
	List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);	//2. 重点：typesBySubscriber是一个HashMap，key为注册subscriber的当前类MainActivity，value为当前类包含的所有类型Subscriber
	// 不存在则创建一个subscribedEvents，并保存到typesBySubscriber
	if (subscribedEvents == null) {
		subscribedEvents = new ArrayList<>();
		typesBySubscriber.put(subscriber, subscribedEvents);
	}
	subscribedEvents.add(eventType);	//2. 将注册的Subscriber对应的事件类型eventType保存到typesBySubscriber
	// 粘性事件相关的，后边具体分析
	if (subscriberMethod.sticky) {
		if (eventInheritance) {
			// Existing sticky events of all subclasses of eventType have to be considered.
			// Note: Iterating over all events may be inefficient with lots of sticky events,
			// thus data structure should be changed to allow a more efficient lookup
			// (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
			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);
			checkPostStickyEventToSubscription(newSubscription, stickyEvent);
		}
	}
}

注册的Subscriber将会保存到subscriptionsByEventType和typesBySubscriber
subscriptionsByEventType是一个HashMap，key为注册Subscriber监听事件的事件类型eventType，value为所有监听相同事件类型为eventType的Subscriber
typesBySubscriber是一个HashMap，key为注册Subscriber的当前类MainActivity，value为当前类包含的所有类型Subscriber

4.2 post发送事件

EventBus.getDefault().post(new MyEvent(time));

源码分析：

public void post(Object event) {
	// currentPostingThreadState是一个PostingThreadState类型的ThreadLocal
	// PostingThreadState类保存了事件队列和线程模式等信息
	PostingThreadState postingState = currentPostingThreadState.get();
	List<Object> eventQueue = postingState.eventQueue;
	// 将要发送的事件添加到事件队列
	eventQueue.add(event);
	// isPosting默认为false
	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()) {
				// 发送单个事件
				// eventQueue.remove(0)，从事件队列移除事件
				postSingleEvent(eventQueue.remove(0), postingState);
			}
		} finally {
			postingState.isPosting = false;
			postingState.isMainThread = false;
		}
	}
}

将发送的事件保存到eventQueue，并遍历eventQueue执行postSingleEvent处理事件

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
	Class<?> eventClass = event.getClass();
	boolean subscriptionFound = false;
	// eventInheritance默认为true，表示是否向上查找事件的父类
	if (eventInheritance) {
		// 查找当前事件类型的Class，连同当前事件类型的Class保存到集合
		List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
		int countTypes = eventTypes.size();
		// 遍历Class集合，继续处理事件
		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));
		}
	}
}

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
	CopyOnWriteArrayList<Subscription> subscriptions;
	synchronized (this) {
		// 获取事件类型对应的Subscription集合
		subscriptions = subscriptionsByEventType.get(eventClass);
	}
	// 如果已订阅了对应类型的事件
	if (subscriptions != null && !subscriptions.isEmpty()) {
		for (Subscription subscription : subscriptions) {
			// 记录事件
			postingState.event = event;
			// 记录对应的subscription
			postingState.subscription = subscription;
			boolean aborted = false;
			try {
				// 最终的事件处理
				postToSubscription(subscription, event, postingState.isMainThread);
				aborted = postingState.canceled;
			} finally {
				postingState.event = null;
				postingState.subscription = null;
				postingState.canceled = false;
			}
			if (aborted) {
				break;
			}
		}
		return true;
	}
	return false;
}

根据当前发送事件的事件类型，从subscriptionsByEventType中获所有监听此事件类型的Subscriber，遍历这些Subscriber并执行postToSubscription进行进一步处理，即所有监听此事件的Subscriber对应的方法都会被调用

4.3 处理事件

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
	// 判断订阅事件方法的线程模式
	switch (subscription.subscriberMethod.threadMode) {
		// 默认的线程模式，在那个线程发送事件就在那个线程处理事件
		case POSTING:
			invokeSubscriber(subscription, event);
			break;
		// 在主线程处理事件
		case MAIN:
			// 如果在主线程发送事件，则直接在主线程通过反射处理事件
			if (isMainThread) {
				invokeSubscriber(subscription, event);
			} else {
				 // 如果是在子线程发送事件，则将事件入队列，通过Handler切换到主线程执行处理事件
				// mainThreadPoster 不为空
				mainThreadPoster.enqueue(subscription, event);
			}
			break;
		// 无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。
		// mainThreadPoster 不为空
		case MAIN_ORDERED:
			if (mainThreadPoster != null) {
				mainThreadPoster.enqueue(subscription, event);
			} else {
				invokeSubscriber(subscription, event);
			}
			break;
		case BACKGROUND:
			// 如果在主线程发送事件，则先将事件入队列，然后通过线程池依次处理事件
			if (isMainThread) {
				backgroundPoster.enqueue(subscription, event);
			} else {
				// 如果在子线程发送事件，则直接在发送事件的线程通过反射处理事件
				invokeSubscriber(subscription, event);
			}
			break;
		// 无论在那个线程发送事件，都将事件入队列，然后通过线程池处理。
		case ASYNC:
			asyncPoster.enqueue(subscription, event);
			break;
		default:
			throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
	}
}

根据订阅事件方法的线程模式、以及发送事件的线程来判断如何处理事件

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);
	}
}

使用反射来执行订阅事件event的方法onEvent，这样发送出去的事件就被订阅者Subscriber接收并做相应处理了

4.4 粘性事件

EventBus.getDefault().postSticky(new MyEvent(time));

源码分析：

public void postSticky(Object event) {
	synchronized (stickyEvents) {
		stickyEvents.put(event.getClass(), event);
	}
	post(event);
}

将发送的粘性事件保存到stickyEvents中

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
	......
	......
	......
	// 如果当前订阅事件的方法的Subscribe注解的sticky属性为true，即该方法可接受粘性事件
	if (subscriberMethod.sticky) {
		// 默认为true，表示是否向上查找事件的父类
		if (eventInheritance) {
			// stickyEvents就是发送粘性事件时，保存了事件类型和对应事件
			Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
			for (Map.Entry<Class<?>, Object> entry : entries) {
				Class<?> candidateEventType = entry.getKey();
				// 如果candidateEventType是eventType的子类或
				if (eventType.isAssignableFrom(candidateEventType)) {
					// 获得对应的事件
					Object stickyEvent = entry.getValue();
					// 处理粘性事件
					checkPostStickyEventToSubscription(newSubscription, stickyEvent);
				}
			}
		} else {
			Object stickyEvent = stickyEvents.get(eventType);
			checkPostStickyEventToSubscription(newSubscription, stickyEvent);
		}
	}
}
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
	if (stickyEvent != null) {
		postToSubscription(newSubscription, stickyEvent, isMainThread());
	}
}

eventType为当前Subscriber监听的事件类型，从stickyEvents取出发送的粘性事件，如果注册的Subscriber监听的事件类型正好为粘性事件的事件类型，则直接调用checkPostStickyEventToSubscription进行事件处理

5. EventBus总结

注册事件：将注册的Subscriber保存到subscriptionsByEventType和typesBySubscriber
subscriptionsByEventType是一个HashMap，key为注册Subscriber监听事件的事件类型eventType，value为所有监听相同事件类型为eventType的Subscriber
typesBySubscriber是一个HashMap，key为注册Subscriber的当前类MainActivity，value为当前类包含的所有类型Subscriber
发送事件：根据当前发送事件的事件类型，从subscriptionsByEventType中获所有监听此事件类型的Subscriber，遍历这些Subscriber并执行postToSubscription进行进一步处理，即所有监听此事件的Subscriber对应的方法都会被调用
处理事件：使用反射来执行订阅事件event的方法onEvent，这样发送出去的事件就被订阅者Subscriber接收并做相应处理了

好文章：
https://www.jianshu.com/p/d9516884dbd4
https://www.6hu.cc/archives/215.html

暖阳55555

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android系统之EventBus用法及源码分析

1. EventBus简介EventBus是一款在Android开发中使用的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分开，简化了组件之间的通信，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。使用简单、效率高、体积小！下边是官方的 EventBus 原理图：2. EventBus使用方法2.1 使用步骤a. 添加依赖库在项目对应的build.gradle文件添加compile 'org.greenrobot:eventbus:3.0.0'b.
复制链接

扫一扫