EventBus 3.0 源码分析

EventBus 3.0源码分析

简介

EvenntBus 是一个开源库，它利用发布/订阅者者模式来对项目进行解耦。它可以利用很少的代码，来实现多组件间通信。android的组件间通信，我们不由得会想到handler消息机制和广播机制，通过它们也可以进行通信，但是使用它们进行通信，代码量多，组件间容易产生耦合引用。关于EventBus的工作模式，这里引用一张官方图帮助理解。

为什么会选择使用EventBus来做通信？

• 简化了组件间交流的方式
• 对事件通信双方进行解耦
• 可以灵活方便的指定工作线程，通过ThreadMode
• 速度快，性能好
• 库比较小，60k左右，对包大小无影响
• 使用这个库的app多，有权威性
• 功能多，使用方便

EventBus的使用也非常简单，三板斧。register，unregister, subscribe/post

三个重要的角色

1:Publisher 事件发布者

2:Subscriber 事件订阅者

3:Event 事件

Publisher post 事件后，Subscriber会自动收到事件(订阅方法会被主动调用，并将事件传递过来)。

使用

 //倒入gradle 依赖
 implementation 'org.greenrobot:eventbus:3.3.1'

1:定义事件类型

public static class MessageEvent { /* Additional fields if needed */ }

2:在需要订阅事件的模块中注册EventBus，页面销毁时注意注销

 @Override
 protected void onStart() {
       super.onStart();
    EventBus.getDefault().register(this);    
 }

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

3:注册需要接受的事件类型 //注意同一种事件类型不能重复注册。不然会崩溃，且订阅方法必须是public类型的。

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {
    // Do something
}

4.发送事件

EventBus.getDefault().post(new MessageEvent());
这是步骤3种的方法就会收到MessageEvent事件的回调

源码分析

EventBus 主类中只有不到600行代码，非常精简。EventBus使用了对外提供了单例模型，内部构建使用了Build模式。

1 register

public void register(Object subscriber) {
    if (AndroidDependenciesDetector.isAndroidSDKAvailable() &&     !AndroidDependenciesDetector.areAndroidComponentsAvailable()) {
        // Crash if the user (developer) has not imported the Android compatibility library.
        throw new RuntimeException("It looks like you are using EventBus on Android, " +
                "make sure to add the \"eventbus\" Android library to your dependencies.");
    }

        //1从这里开始看，获取调用者的类对象。
    Class subscriberClass = subscriber.getClass();
    //2 找到订阅类中的订阅方法
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    
    //3遍历订阅方法，将订阅者和其中的订阅方法绑定。
       synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

Step1

看下步骤2中的subscriberMethodFinder的findSubscriberMethods方法

List findSubscriberMethods(Class subscriberClass) {    
        //1首先从缓存map中拿到订阅类的订阅方法列表，使用了缓存提高性能，nice，不出所料METHOD_CACHE的类型是Map, List >
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);
    //2 如果不为空，说明之前该类曾经注册过，该类的新对象不必重新做绑定了，因为此时的操作是类层面的
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
        //如果subscriberMethods 为null,说明该类是第一次注册，需要将其中的接收方法保存起来，
      //ignoreGeneratedIndex 默认为false
    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    //如果subscriberMethods为null，说明当前类对象没有生命订阅方法，抛出异常
    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;
    }
}

Step2

从步骤2中找出类的注册方法列表，然后遍历列表，调用下面的方法，将类对象和注册方法绑定。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //1 找到订阅方法的事件类型，即发送事件的MessageEvent.class
    Class eventType = subscriberMethod.eventType;
  
      //2 将订阅者类对象和订阅事件绑定成一个对象
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    //subscriptionsByEventType 这个集合肯定是用来放置同一事件类型的订阅集合的，因为一个事件可能会有多个订阅的。
    CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
            //如果一个订阅者多次订阅了一个事件（@Subscribe注解的方法的参数是同一类型），抛出异常
        if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                    + eventType);
        }
    }

        //3 按照订阅方法中@Subscribe中的priority参数进行排序，默认为最低优先级0。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);
            break;
        }
    }

        // typesBySubscriber类型Map>>,Key 为订阅者，value为订阅者中的订阅方法，用来记录每个订阅者内部都订阅了哪些事件类型
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);

    //粘性事件相关
    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).
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, 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);
        }
    }
}

2 post

/** Posts the given event to the event bus. */
public void post(Object event) {
        //1首先获取当前线程的工作状态
    PostingThreadState postingState = currentPostingThreadState.get();
    //2获取当前线程的任务队列
    List