EventBus 源码分析 - 注解 + 反射

AI大模型-bugyinyin

已于 2022-06-30 17:27:15 修改

阅读量444

点赞数

CC 4.0 BY-SA版权

分类专栏： Android 项目实战文章标签： java android kotlin

于 2022-05-11 21:55:10 首次发布

本文链接：https://blog.csdn.net/bugyinyin/article/details/124720079

Android 同时被 2 个专栏收录

210 篇文章

订阅专栏

项目实战

5 篇文章

订阅专栏

本文详细解析了EventBus的源码，包括getDefault()方法的DCL单例模式，register()方法中通过反射查找@Subscribe注解的方法，以及post()方法如何依据eventType执行订阅方法。EventBus利用注解和反射实现订阅发布机制，同时涉及线程模式、优先级和粘性事件的处理。此外，还介绍了unregister()方法清理相关数据。整个过程展示了EventBus设计的巧妙之处。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

EventBus 源码解析

随着 LiveData 和 Kotlin Flow 的出现，EventBus 已经慢慢过时了。不过 EventBus 源码的设计思想以及实现原理还是值得我们去学习的。

getDefault() 方法

EventBus().getDefault().register(this)

首先 EventBus 的创建用到了 DCL 单例模式，源码如下：

public class EventBus {
   
    static volatile EventBus defaultInstance;
   
    public static EventBus getDefault() {
        EventBus instance = defaultInstance;
        if (instance == null) {
            synchronized (EventBus.class) {
                instance = EventBus.defaultInstance;
                if (instance == null) {
                    instance = EventBus.defaultInstance = new EventBus();
                }
            }
        }
        return instance;
    }
}

register() 方法第一部分

示例：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
       
        EventBus.getDefault().register(this);
    }

    /**
     * threadMode 执行的线程方式
     * priority 执行的优先级
     * sticky 粘性事件
     */
    @Subscribe(threadMode = ThreadMode.MAIN,priority = 50,sticky = true)
    public void test1(String msg){
        // 如果有一个地方用 EventBus 发送一个 String 对象，那么这个方法就会被执行
        Log.e("TAG","msg1 = "+msg);
    }
    
    @Subscribe(threadMode = ThreadMode.MAIN,priority = 100,sticky = true)
    public void test2(String msg){
        // 如果有一个地方用 EventBus 发送一个 String 对象，那么这个方法就会被执行
        Log.e("TAG","msg2 = "+msg);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        
        EventBus.getDefault().unregister(this);
    }
}

EventBus().getDefault().post("text")

register() 方法源码：

public void register(Object subscriber) {
    
    // 获取 class 对象
    Class<?> subscriberClass = subscriber.getClass();
    
    // 遍历这个 class 的所有方法，将含有 @Subscribe 注解的方法找出来
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

这里的 subscriber 就是我们的 MainActivity，第一行代码很简单，就是获取 MainActivity 的 class 对象。

第二行代码的意思：遍历这个 class 的所有方法，将含有 @Subscribe 注解的方法找出来，并将它们封装成 List<SubscriberMethod>。SubscriberMethod 的成员变量如下所示：

我们来看下 findSubscriberMethods 源码：

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

这里的 subscriberClass 就是我们的 MainActivity 的 class 对象。

ignoreGeneratedIndex 这个属性表示是否忽略注解成器生成的 EventBusIndex.class 文件, 我们只要知道 ignoreGeneratedIndex 默认是 false 就行了。

所以会走 findUsingInfo(subscriberClass) 方法，我们来看下源码：

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        findState.subscriberInfo = getSubscriberInfo(findState);
        if (findState.subscriberInfo != null) {
            SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
            for (SubscriberMethod subscriberMethod : array) {
                if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                    findState.subscriberMethods.add(subscriberMethod);
                }
            }
        } else {
            // 走这个方法
            findUsingReflectionInSingleClass(findState);
        }
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

这里我直接说结论，因为我们没有使用编译时注解生成 EventBusIndex.class 文件，所以 findState.subscriberInfo 为空，所以这里会走 findUsingReflectionInSingleClass(findState) 方法，最终就是通过反射去找。我们来看下 findUsingReflectionInSingleClass 源码：

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
       ......
        }
    }
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        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()));
                    }
                }
            } 
        } 
    }
}

第一行代码 findState.clazz.getDeclaredMethods(); 就是通过反射获取订阅类的所有方法。

然后遍历 methods，判断方法的修饰符是不是 public，然后获取方法参数的 class，并判断是不是只有一个参数，并且还判断是否被 @Subscribe 修饰。method.getParameterTypes() 就是获取方法的参数类型。String msg 获取到的就是 String.class，如下：

遍历完 methods 之后，就会将所获得的属性添加到 subscriberMethods 中，如下：

findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode, subscribeAnnotation.priority(), subscribeAnnotation.sticky()));

最后通过 findState 将 subscriberMethods 返回回去。也就是 register() 方法中的List<SubscriberMethod>。

第一部分小结

public void register(Object subscriber) {
    
    // 获取 class 对象
    Class<?> subscriberClass = subscriber.getClass();
    
    // 遍历这个 class 的所有方法，将含有 @Subscribe 注解的方法找出来
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

subscriberMethodFinder.findSubscriberMethods() 方法就是通过反射去解析注册者（MainActivity）的所有方法。并且找出被 @Subscribe 注解修饰的方法，然后通过 Annotation 解析所有需要的参数（包括 threadMode、priority、sticky、参数的类型 eventType、method）。最后把这些参数封装成 SubscriberMethod 添加到集合返回。

findSubscriberMethods 方法完成后图解.png

register() 方法第二部分

接下来我们来分析 subscribe 方法：

synchronized (this) {
    for (SubscriberMethod subscriberMethod : subscriberMethods) {
        subscribe(subscriber, subscriberMethod);
    }
}

我们先看一下 subscribe() 方法的参数，subscriber 参数就是我们的 MainActivity，subscriberMethod 参数是我们上面对方法的封装。

我们来看一下 subscribe() 方法的源码：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    // eventType 是方法参数的 class，也就是 String.class
    Class<?> eventType = subscriberMethod.eventType;
    
    // 又封装了一个 Subscription 对象 subscriber : MainActivity, subscriberMethod : 解析好的方法
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    
    CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    
    // 第一次拿为空，put
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
        ......
    }

    // 优先级排序 
    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;
        }
    }

    List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);

    // 粘性事件的处理
    ```
}

这里又封装了一个 Subscription 对象，成员变量就是：

subscriber 参数就是我们的 MainActivity
subscriberMethod 参数是我们上面对方法的封装

接下来用 subscriptionsByEventType 将 Subscription 对象存起来，subscriptionsByEventType 是个 Map，如下：

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

key : Class<?>(参数类型，也就是 Strin.class)
value : CopyOnWriteArrayList<Subscription>(线程安全的 ArrayList，里面是 Subscription)

subscriptionsByEventType.get(eventType) 第一次拿肯定为空，所以会调用 subscriptionsByEventType.put(eventType, subscriptions)。到这里，subscriber 方法就分析好了。

第二部分小结

解析所有的 subscriberMethod 的 eventType，然后将它们封装成 Map<Class<?>, CopyOnWriteArrayList<Subscription>> 类型的 subscriptionsByEventType，key 是 eventType，value 是 Subscription 的列表，Subscription 包含两个属性 subscriber 和 subscriberMethod。

subscribe 完成后图解.png

post() 方法

其实根据上面那个图，我们很容易猜出 post() 方法肯定会遍历 subscriptionsByEventType，找到一样的 eventType，然后去执行 CopyOnWriteArrayList 列表里面的 Subscription 对象里面的 subscriberMethod 对象里面的 method。

我们来看下 post() 方法源码：(经过一系列调用)

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {

    CopyOnWriteArrayList<Subscription> subscriptions;
    
    synchronized (this) {
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    
    if (subscriptions != null && !subscriptions.isEmpty()) {
        for (Subscription subscription : subscriptions) {
            postingState.event = event;
            postingState.subscription = subscription;
            boolean aborted;
            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;
}

这里的 event 就是 post("text") 里面的 text，所以 eventClass 就是 String.class，然后执行 subscriptions = subscriptionsByEventType.get(eventClass)，就会将我们上面图片中的 value 取出来。然后遍历 subscriptions，执行 postToSubscription(subscription, event, postingState.isMainThread) 方法，我们看下这个方法的源码：

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 {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case MAIN_ORDERED:
            if (mainThreadPoster != null) {
                mainThreadPoster.enqueue(subscription, event);
            } else {
                // temporary: technically not correct as poster not decoupled from subscriber
                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);
    }
}

我们的 threadMode 有四种形式：

POSTING：同一个线程，在哪个线程发送，就在哪个线程执行。
MAIN：在主线中执行。
BACKGROUND：子线程，如果发送事件是主线程，那么久调用线程池切换线程来执行方法。
ASYNC：异步线程，无论发布时间是主线程还是子线程，都有通过线程池切换线程执行。

所以我们看到源码中，如果是 POSTING 方式就直接调用 invokeSubscriber(subscription, event) 执行方法。其他方式就可能需要调用线程池切换线程来执行订阅方法。

invokeSubscriber 源码如下：

void invokeSubscriber(Subscription subscription, Object event) {
    try {
      //  subscriber 是 MainActivity，event 是 post 发送的 "text"
      subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
    } catch (InvocationTargetException e) {
        handleSubscriberException(subscription, event, e.getCause());
    } catch (IllegalAccessException e) {
        throw new IllegalStateException("Unexpected exception", e);
    }
}

post() 方法小结

post() 方法会将 post(Object event) 里的 event 的 class 对象作为 key，去 subscriptionsByEventType 这个 map 里面取出 key 跟 event 的 class 相同的 subscriptions，然后遍历 subscriptions去执行订阅方法。