EventBus三之手写EventBus
目录
- 项目模块描述
- eventbus_annotation模块
- eventbus_compiler模块
- eventbus模块
- 代码传送门
项目模块描述
eventbus类图
eventbus时序图
eventbus_annotation 实现
a）定义注解类Subscribe
@Target(ElementType.METHOD) // 该注解作用在方法之上
@Retention(RetentionPolicy.CLASS) // 要在编译时进行一些预处理操作，注解会在class文件中存在
public @interface Subscribe {
// 线程模式，默认推荐POSTING（订阅、发布在同一线程）
ThreadMode threadMode() default ThreadMode.POSTING;
// 是否使用粘性事件
boolean sticky() default false;
// 事件订阅优先级，在同一个线程中。数值越大优先级越高。
int priority() default 0;
}
b）定义ThreadMode
public enum ThreadMode {
// 订阅、发布在同一线程。避免了线程切换，也是推荐的默认模式
POSTING,
// 主线程（UI线程）中被调用，切勿耗时操作
MAIN,
// 用于网络访问等耗时操作，事件总线已完成的异步订阅通知线程。并使用线程池有效地重用
ASYNC
}
c）定义订阅方法的描述类
public interface SubscriberInfo {
// 订阅所属类，比如：MainActivity
Class<?> getSubscriberClass();
// 获取订阅所属类中所有订阅事件的方法（此处不使用List是因为注解处理器每次都要list.clear()，麻烦！）
SubscriberMethod[] getSubscriberMethods();
}
public class EventBeans implements SubscriberInfo {
// 订阅者对象Class，如：MainActivity.class
private final Class subscriberClass;
// 订阅方法数组，参考SimpleSubscriberInfo.java 25行
private final SubscriberMethod[] methodInfos;
public EventBeans(Class subscriberClass, SubscriberMethod[] methodInfos) {
this.subscriberClass = subscriberClass;
this.methodInfos = methodInfos;
}
@Override
public Class<?> getSubscriberClass() {
return subscriberClass;
}
@Override
public synchronized SubscriberMethod[] getSubscriberMethods() {
return methodInfos;
}
}
public class SubscriberMethod {
private String methodName; // 订阅方法名
private Method method; // 订阅方法，用于最后的自动执行订阅方法
private ThreadMode threadMode; // 线程模式
private Class<?> eventType; // 事件对象Class，如：UserInfo.class
private int priority; // 事件订阅优先级（实现思路：重排序集合中方法的顺序）
private boolean sticky; // 是否粘性事件（实现思路：发送时存储，注册时判断粘性再激活）
public SubscriberMethod(Class subscriberClass, String methodName,
Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
this.methodName = methodName;
this.threadMode = threadMode;
this.eventType = eventType;
this.priority = priority;
this.sticky = sticky;
try {
// 订阅所属类（参考源码：AbstractSubscriberInfo.java - 72行）
method = subscriberClass.getDeclaredMethod(methodName, eventType);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
...
}
d）定义订阅索引接口
public interface SubscriberInfoIndex {
/**
* 生成索引接口，通过订阅者对象（MainActivity.class）获取所有订阅方法
*
* @param subscriberClass 订阅者对象Class，如：MainActivity.class
* @return 事件订阅方法封装类
*/
SubscriberInfo getSubscriberInfo(Class<?> subscriberClass);
}
eventbus_compiler 实现
// 注解处理器的实现
/**
* 编码此类1句话：细心再细心，出了问题debug真的不好调试
*/
// 用来生成 META-INF/services/javax.annotation.processing.Processor 文件
@AutoService(Processor.class)
// 允许/支持的注解类型，让注解处理器处理
@SupportedAnnotationTypes({Constants.SUBSCRIBE_ANNOTATION_TYPES})
// 指定JDK编译版本
@SupportedSourceVersion(SourceVersion.RELEASE_7)
// 注解处理器接收的参数
@SupportedOptions({Constants.PACKAGE_NAME, Constants.CLASS_NAME})
public class SubscribeProcessor extends AbstractProcessor {
// 操作Element工具类 (类、函数、属性都是Element)
private Elements elementUtils;
// type(类信息)工具类，包含用于操作TypeMirror的工具方法
private Types typeUtils;
// Messager用来报告错误，警告和其他提示信息
private Messager messager;
// 文件生成器 类/资源，Filter用来创建新的类文件，class文件以及辅助文件
private Filer filer;
// APT包名
private String packageName;
// APT类名
private String className;
// 临时map存储，用来存放订阅方法信息，生成路由组类文件时遍历
// key:组名"MainActivity", value:MainActivity中订阅方法集合
private final Map<TypeElement, List<ExecutableElement>> methodsByClass = new HashMap<>();
// 该方法主要用于一些初始化的操作，通过该方法的参数ProcessingEnvironment可以获取一些列有用的工具类
@Override
public synchronized void init(ProcessingEnvironment processingEnvironment) {
super.init(processingEnvironment);
// 初始化
elementUtils = processingEnvironment.getElementUtils();
typeUtils = processingEnvironment.getTypeUtils();
messager = processingEnvironment.getMessager();
filer = processingEnvironment.getFiler();
// 通过ProcessingEnvironment去获取对应的参数
Map<String, String> options = processingEnvironment.getOptions();
if (!EmptyUtils.isEmpty(options)) {
packageName = options.get(Constants.PACKAGE_NAME);
className = options.get(Constants.CLASS_NAME);
messager.printMessage(Diagnostic.Kind.NOTE,
"packageName >>> " + packageName + " / className >>> " + className);
}
// 必传参数判空（乱码问题：添加java控制台输出中文乱码）
if (EmptyUtils.isEmpty(packageName) || EmptyUtils.isEmpty(className)) {
messager.printMessage(Diagnostic.Kind.ERROR, "注解处理器需要的参数为空，请在对应build.gradle配置参数");
}
}
/**
* 相当于main函数，开始处理注解
* 注解处理器的核心方法，处理具体的注解，生成Java文件
*
* @param set 使用了支持处理注解的节点集合
* @param roundEnvironment 当前或是之前的运行环境,可以通过该对象查找的注解。
* @return true 表示后续处理器不会再处理（已经处理完成）
*/
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
// 一旦有类之上使用@Subscribe注解
if (!EmptyUtils.isEmpty(set)) {
// 获取所有被 @Subscribe 注解的 元素集合
Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(Subscribe.class);
if (!EmptyUtils.isEmpty(elements)) {
// 解析元素
try {
parseElements(elements);
return true;
} catch (IOException e) {
e.printStackTrace();
}
}
return true;
}
return false;
}
// 解析所有被 @Subscribe 注解的 类元素集合
private void parseElements(Set<? extends Element> elements) throws IOException {
// 遍历节点
for (Element element : elements) {
// @Subscribe注解只能在方法之上（尽量避免使用instanceof进行判断）
if (element.getKind() != ElementKind.METHOD) {
messager.printMessage(Diagnostic.Kind.ERROR, "仅解析@Subscribe注解在方法上元素");
return;
}
// 强转方法元素
ExecutableElement method = (ExecutableElement) element;
// 检查方法，条件：订阅方法必须是非静态的，公开的，参数只能有一个
if (checkHasNoErrors(method)) {
// 获取封装订阅方法的类（方法上一个节点）
TypeElement classElement = (TypeElement) method.getEnclosingElement();
// 以类名为key，保存订阅方法
List<ExecutableElement> methods = methodsByClass.get(classElement);
if (methods == null) {
methods = new ArrayList<>();
methodsByClass.put(classElement, methods);
}
methods.add(method);
}
messager.printMessage(Diagnostic.Kind.NOTE, "遍历注解方法：" + method.getSimpleName().toString());
}
// 通过Element工具类，获取SubscriberInfoIndex类型
TypeElement subscriberIndexType = elementUtils.getTypeElement(Constants.SUBSCRIBERINFO_INDEX);
// 生成类文件
createFile(subscriberIndexType);
}
private void createFile(TypeElement subscriberIndexType) throws IOException {
// 添加静态块代码：SUBSCRIBER_INDEX = new HashMap();
CodeBlock.Builder codeBlock = CodeBlock.builder();
codeBlock.addStatement("$N = new $T<$T, $T>()",
Constants.FIELD_NAME,
HashMap.class,
Class.class,
SubscriberInfo.class);
// 双层循环，第一层遍历被@Subscribe注解的方法所属类。第二层遍历每个类中所有订阅的方法
for (Map.Entry<TypeElement, List<ExecutableElement>> entry : methodsByClass.entrySet()) {
// 此处不能使用codeBlock，会造成错误嵌套
CodeBlock.Builder contentBlock = CodeBlock.builder();
CodeBlock contentCode = null;
String format;
for (int i = 0; i < entry.getValue().size(); i++) {
// 获取每个方法上的@Subscribe注解中的注解值
Subscribe subscribe = entry.getValue().get(i).getAnnotation(Subscribe.class);
// 获取订阅事件方法所有参数
List<? extends VariableElement> parameters = entry.getValue().get(i).getParameters();
// 获取订阅事件方法名
String methodName = entry.getValue().get(i).getSimpleName().toString();
// 注意：此处还可以做检查工作，比如：参数类型必须是类或接口类型（这里缩减了）
TypeElement parameterElement = (TypeElement) typeUtils.asElement(parameters.get(0).asType());
// 如果是最后一个添加，则无需逗号结尾
if (i == entry.getValue().size() - 1) {
format = "new $T($T.class, $S, $T.class, $T.$L, $L, $L)";
} else {
format = "new $T($T.class, $S, $T.class, $T.$L, $L, $L),\n";
}
// new SubscriberMethod(MainActivity.class, "abc", UserInfo.class, ThreadMode.POSTING, 0, false)
contentCode = contentBlock.add(format,
SubscriberMethod.class,
ClassName.get(entry.getKey()),
methodName,
ClassName.get(parameterElement),
ThreadMode.class,
subscribe.threadMode(),
subscribe.priority(),
subscribe.sticky())
.build();
}
if (contentCode != null) {
// putIndex(new EventBeans(MainActivity.class, new SubscriberMethod[] {)
codeBlock.beginControlFlow("putIndex(new $T($T.class, new $T[]",
EventBeans.class,
ClassName.get(entry.getKey()),
SubscriberMethod.class)
// 嵌套的精华（尝试了很多次，有更好的方式请告诉我）
.add(contentCode)
// ))}
.endControlFlow("))");
} else {
messager.printMessage(Diagnostic.Kind.ERROR, "注解处理器双层循环发生错误！");
}
}
// 全局属性：Map, SubscriberMethod>
TypeName fieldType = ParameterizedTypeName.get(
ClassName.get(Map.class), // Map
ClassName.get(Class.class), // Map
ClassName.get(SubscriberInfo.class) // Map, SubscriberMethod> SUBSCRIBER_INDEX
.addField(fieldType, Constants.FIELD_NAME, Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
// 第一个方法：加入全局Map集合
.addMethod(putIndexBuidler.build())
// 第二个方法：通过订阅者对象（MainActivity.class）获取所有订阅方法
.addMethod(getSubscriberInfoBuidler.build())
.build();
// 生成类文件：EventBusIndex
JavaFile.builder(packageName, // 包名
typeSpec) // 类构建完成
.build() // JavaFile构建完成
.writeTo(filer); // 文件生成器开始生成类文件
}
/**
* 检查方法，条件：订阅方法必须是非静态的，公开的，参数只能有一个
*
* @param element 方法元素
* @return 检查是否通过
*/
private boolean checkHasNoErrors(ExecutableElement element) {
// 不能为static静态方法
if (element.getModifiers().contains(Modifier.STATIC)) {
messager.printMessage(Diagnostic.Kind.ERROR, "订阅事件方法不能是static静态方法", element);
return false;
}
// 必须是public修饰的方法
if (!element.getModifiers().contains(Modifier.PUBLIC)) {
messager.printMessage(Diagnostic.Kind.ERROR, "订阅事件方法必须是public修饰的方法", element);
return false;
}
// 订阅事件方法必须只有一个参数
List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters();
if (parameters.size() != 1) {
messager.printMessage(Diagnostic.Kind.ERROR, "订阅事件方法有且仅有一个参数", element);
return false;
}
return true;
}
}
EventBus的实现
public class EventBus {
// volatile修饰的变量不允许线程内部缓存和重排序,即直接修改内存
private static volatile EventBus defaultInstance;
// 索引接口
private SubscriberInfoIndex subscriberInfoIndexes;
// 订阅者类型集合，比如：订阅者MainActivity订阅了哪些EventBean，或者解除订阅的缓存。
// key：订阅者MainActivity.class，value：EventBean集合
private Map<Object, List<Class<?>>> typesBySubscriber;
// 方法缓存：key：订阅者MainActivity.class，value：订阅方法集合
private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>();
// EventBean缓存，key：UserInfo.class，value：订阅者（可以是多个Activity）中所有订阅的方法集合
private Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
// 粘性事件缓存，key：UserInfo.class，value：UserInfo
private final Map<Class<?>, Object> stickyEvents;
// 发送（子线程） - 订阅（主线程）
private Handler handler;
// 发送（主线程） - 订阅（子线程）
private ExecutorService executorService;
private EventBus() {
// 初始化缓存集合
typesBySubscriber = new HashMap<>();
subscriptionsByEventType = new HashMap<>();
stickyEvents = new HashMap<>();
// Handler高级用法：将handler放在主线程使用
handler = new Handler(Looper.getMainLooper());
// 创建一个子线程（缓存线程池）
executorService = Executors.newCachedThreadPool();
}
// 单例，全局唯一，参考EventBus.java 80行
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
}
// 添加索引（简化），接口 = 接口实现类，参考EventBusBuilder.java 136行
public void addIndex(SubscriberInfoIndex index) {
subscriberInfoIndexes = index;
}
// 注册 / 订阅事件，参考EventBus.java 138行
public void register(Object subscriber) {
// 获取MainActivity.class
Class<?> subscriberClass = subscriber.getClass();
// 寻找（MainActivity.class）订阅方法集合
List<SubscriberMethod> subscriberMethods = findSubscriberMethods(subscriberClass);
synchronized (this) { // 同步锁，并发少可考虑删除（参考源码）
for (SubscriberMethod subscriberMethod : subscriberMethods) {
// 遍历后，开始订阅
subscribe(subscriber, subscriberMethod);
}
}
}
// 寻找（MainActivity.class）订阅方法集合，参考SubscriberMethodFinder.java 55行
private List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
// 从方法缓存中读取
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
// 找到了缓存，直接返回
if (subscriberMethods != null) {
return subscriberMethods;
}
// 找不到，从APT生成的类文件中寻找
subscriberMethods = findUsingInfo(subscriberClass);
if (subscriberMethods != null) {
// 存入缓存
METHOD_CACHE.put(subscriberClass, subscriberMethods);
}
return subscriberMethods;
}
// 遍历中……并开始订阅，参考EventBus.java 149行
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
// 获取订阅方法参数类型，如：UserInfo.class
Class<?> eventType = subscriberMethod.getEventType();
// 临时对象存储
Subscription subscription = new Subscription(subscriber, subscriberMethod);
// 读取EventBean缓存
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
// 初始化集合
subscriptions = new CopyOnWriteArrayList<>();
// 存入缓存
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(subscription)) {
Log.e("netease >>> ", subscriber.getClass() + "重复注册粘性事件！");
// 执行多次粘性事件，但不添加到集合，避免订阅方法多次执行
sticky(subscriberMethod, eventType, subscription);
return;
}
}
// 订阅方法优先级处理。第一次进来肯定是0，参考EventBus.java 163行
int size = subscriptions.size();
// 这里的i <= size，否则进不了下面条件
for (int i = 0; i <= size; i++) {
// 如果满足任一条件则进入循环（第1次 i = size = 0）
// 第2次，size不为0，新加入的订阅方法匹配集合中所有订阅方法的优先级
if (i == size || subscriberMethod.getPriority() > subscriptions.get(i).subscriberMethod.getPriority()) {
// 如果新加入的订阅方法优先级大于集合中某订阅方法优先级，则插队到它之前一位
if (!subscriptions.contains(subscription)) subscriptions.add(i, subscription);
// 优化：插队成功就跳出（找到了加入集合点）
break;
}
}
// 订阅者类型集合，比如：订阅者MainActivity订阅了哪些EventBean，或者解除订阅的缓存
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
// 存入缓存
typesBySubscriber.put(subscriber, subscribedEvents);
}
// 注意：subscribe()方法在遍历过程中，所以一直在添加
subscribedEvents.add(eventType);
sticky(subscriberMethod, eventType, subscription);
}
// 抽取原因：可执行多次粘性事件，而不会出现闪退，参考EventBus.java 158行
private void sticky(SubscriberMethod subscriberMethod, Class<?> eventType, Subscription subscription) {
// 粘性事件触发：注册事件就激活方法，因为整个源码只有此处遍历了。
// 最佳切入点原因：1，粘性事件的订阅方法加入了缓存。2，注册时只有粘性事件直接激活方法（隔离非粘性事件）
// 新增开关方法弊端：粘性事件未在缓存中，无法触发订阅方法。且有可能多次执行post()方法
if (subscriberMethod.isSticky()) { // 参考EventBus.java 178行
// 源码中做了继承关系的处理，也说明了迭代效率和更改数据结构方便查找，这里就省略了（真实项目极少）
Object stickyEvent = stickyEvents.get(eventType);
// 发送事件 到 订阅者的所有订阅方法，并激活方法
if (stickyEvent != null) postToSubscription(subscription, stickyEvent);
}
}
// 从APT生成的类文件中寻找订阅方法集合，参考SubscriberMethodFinder.java 64行
private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
// app在运行时寻找索引，报错了则说明没有初始化索引方法
if (subscriberInfoIndexes == null) {
throw new RuntimeException("未添加索引方法：addIndex()");
}
// 接口持有实现类的引用
SubscriberInfo info = subscriberInfoIndexes.getSubscriberInfo(subscriberClass);
// 数组转List集合，参考EventBus生成的APT类文件
if (info != null) return Arrays.asList(info.getSubscriberMethods());
return null;
}
// 是否已经注册 / 订阅，参考EventBus.java 217行
public synchronized boolean isRegistered(Object subscriber) {
return typesBySubscriber.containsKey(subscriber);
}
// 解除某订阅者关系，参考EventBus.java 239行
public synchronized void unregister(Object subscriber) {
// 从缓存中移除
List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
if (subscribedTypes != null) {
// 移除前清空集合
subscribedTypes.clear();
typesBySubscriber.remove(subscriber);
}
}
// 发送粘性事件，最终还是调用了post方法，参考EventBus.java 301行
public void postSticky(Object event) {
// 同步锁保证并发安全（小项目可忽略此处）
synchronized (stickyEvents) {
// 加入粘性事件缓存集合
stickyEvents.put(event.getClass(), event);
}
// 巨坑！！！源码这么写我也不知道什么意图。恶心的后果：只要参数匹配，粘性/非粘性订阅方法全部执行
// post(event);
}
// 获取指定类型的粘性事件，参考EventBus.java 314行
public <T> T getStickyEvent(Class<T> eventType) {
// 同步锁保证并发安全（小项目可忽略此处）
synchronized (stickyEvents) {
// cast方法做转换类型时安全措施（简化stickyEvents.get(eventType)）
return eventType.cast(stickyEvents.get(eventType));
}
}
// 移除指定类型的粘性事件（此处返回值看自己需求，可为boolean），参考EventBus.java 325行
public <T> T removeStickyEvent(Class<T> eventType) {
// 同步锁保证并发安全（小项目可忽略此处）
synchronized (stickyEvents) {
return eventType.cast(stickyEvents.remove(eventType));
}
}
// 移除所有粘性事件，参考EventBus.java 352行
public void removeAllStickyEvents() {
// 同步锁保证并发安全（小项目可忽略此处）
synchronized (stickyEvents) {
// 清理集合
stickyEvents.clear();
}
}
// 发送消息 / 事件
public void post(Object event) {
// 此处两个参数，简化了源码，参考EventBus.java 252 - 265 - 384 - 400行
postSingleEventForEventType(event, event.getClass());
}
// 为EventBean事件类型发布单个事件（遍历），EventBus核心：参数类型必须一致！！！
private void postSingleEventForEventType(Object event, Class<?> eventClass) {
// 从EventBean缓存中，获取所有订阅者和订阅方法
CopyOnWriteArrayList<Subscription> subscriptions;
synchronized (this) {
// 同步锁，保证并发安全
subscriptions = subscriptionsByEventType.get(eventClass);
}
// 判空，健壮性代码
if (subscriptions != null && !subscriptions.isEmpty()) {
for (Subscription subscription : subscriptions) {
// 遍历，寻找发送方指定的EventBean，匹配的订阅方法的EventBean
postToSubscription(subscription, event);
}
}
}
// 发送事件 到 订阅者的所有订阅方法（遍历中……），参考参考EventBus.java 427行
private void postToSubscription(final Subscription subscription, final Object event) {
// 匹配订阅方的线程模式
switch (subscription.subscriberMethod.getThreadMode()) {
case POSTING: // 订阅、发布在同一线程
invokeSubscriber(subscription, event);
break;
case MAIN:
// 订阅方是主线程，则主 - 主
if (Looper.myLooper() == Looper.getMainLooper()) {
invokeSubscriber(subscription, event);
} else {
// 订阅方是子线程，则子 - 主
handler.post(new Runnable() {
@Override
public void run() {
invokeSubscriber(subscription, event);
}
});
}
break;
case ASYNC:
// 订阅方是主线程，则主 - 子
if (Looper.myLooper() == Looper.getMainLooper()) {
// 主线程 - 子线程，创建一个子线程（缓存线程池）
executorService.execute(new Runnable() {
@Override
public void run() {
invokeSubscriber(subscription, event);
}
});
} else {
// 订阅方是子线程，则子 - 子
invokeSubscriber(subscription, event);
}
break;
default:
throw new IllegalStateException("未知线程模式！" + subscription.subscriberMethod.getThreadMode());
}
}
// 执行订阅方法（被注解方法自动执行）参考EventBus.java 505行
private void invokeSubscriber(Subscription subscription, Object event) {
try {
// 无论3.0之前还是之后。最后一步终究逃不过反射！
subscription.subscriberMethod.getMethod().invoke(subscription.subscriber, event);
} catch (Exception e) {
e.printStackTrace();
}
}
// 清理静态缓存（视项目规模调用）
public static void clearCaches() {
METHOD_CACHE.clear();
}
}
javaPoet生成的类文件格式为：
public final class EventBusIndex implements SubscriberInfoIndex {
private static final Map<Class, SubscriberInfo> SUBSCRIBER_INDEX;
static {
SUBSCRIBER_INDEX = new HashMap<Class, SubscriberInfo>();
putIndex(new EventBeans(MainActivity.class, new SubscriberMethod[] {
new SubscriberMethod(MainActivity.class, "handleMessageEvent", MessageEvent.class, ThreadMode.MAIN, 0, false)} ));
}
private static void putIndex(SubscriberInfo info) {
SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
}
@Override
public SubscriberInfo getSubscriberInfo(Class subscriberClass) {
return SUBSCRIBER_INDEX.get(subscriberClass);
}
}
源码传送门