EventBus（3.1.1）源码浅析

前言

EventBus是Android的发布/订阅事件总线，简化了Android的事件传递。提高了代码的简洁性。

官方图.png

1、EventBus的简单使用

public class MainActivity extends BaseActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //注册
        EventBus.getDefault().register(this);
    }
    
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void receiveEventBusMessage(EventBusMessage message){
        Log.e("receive", "receiveEventBusMessage: "+message.getText());
    }

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

//可以在其它组件、fragment或工作线程中发送事件
private void sendMessage(){
        EventBus.getDefault().post(new EventBusMessage("消息："+ new Random().nextInt(50)));
    }

从上面代码可以发现，EventBus实现事件传递有多简洁，无任何花哨。首先，通过register()进行注册，这是使用EventBus的前提；然后声明一个订阅方法用于事件的接收(利用@Subscribe注解)，threadMode指定线程模式(在这里指定于主线程)，其中EventBusMessage是自己定义一个事件类；再然后通过在其它组件、Fragment或工作线程中使用post()发送事件，这样就完成了事件的传递。当组件销毁或者EventBus不再使用时千万别忘记了unregister()解注册。这很重要！！！

2、经过上面的一个简单分析，初步的了解了EventBus的使用。那么，看似简单的几个步骤，里面究竟蕴含了什么内功心法或者招式呢？（故事说起来就长了）前排准备瓜子顺带点小酒。接下来从EventBus.getDefault()开始：

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

//EventBusBuilder以建造者模式初始化一以下属性
EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        subscriptionsByEventType = new HashMap<>();    //订阅的事件类型
        typesBySubscriber = new HashMap<>();           //订阅类型
        stickyEvents = new ConcurrentHashMap<>();      //粘性事件
        mainThreadSupport = builder.getMainThreadSupport(); //主线程接口类
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        backgroundPoster = new BackgroundPoster(this); //在后台提交的事件
        asyncPoster = new AsyncPoster(this);
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        //查找订阅方法的类
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        //获取一个线程池
        executorService = builder.executorService;
    }

很清晰，EventBus.getDefault()利用了单例模式中的双重校验方式获取一个EventBus实例。在构造函数最后一步通过Executors.newCachedThreadPool()创建一个线程池（主要在后台任务或异步任务时使用），对于线程池的创建可以了解这篇文章【探索Java 线程池】

3、EventBus的注册过程(register)。

public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        //获取一个订阅方法List，包含了所订阅的类声明的订阅方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

在上面的代码中可以知道，做了两件事，
1、查找订阅的方法，SubscriberMethodFinder # findSubscriberMethods()
2、进行订阅。subscribe()

3.1、是如何查找已声明的订阅方法？进入SubscriberMethodFinder类的indSubscriberMethods()方法

List findSubscriberMethods(Class subscriberClass) {
       //1
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) { //2
            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 { //3
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

在上面代码1处，首先会从缓存中查找，subscriberClass正是调用register()注册的订阅者，METHOD_CACHE是一个ConcurrentHashMap的实例，从这里可以知道，subscriberClass作为ConcurrentHashMap的key，而ConcurrentHashMap的value（List）存放的是当前订阅者中声明的订阅方法。注释2处表示是否忽略索引的位置，默认为false，因此会在通过findUsingInfo()查找，注释3处把找到的方法保存到METHOD_CACHE中。一起研究findUsingInfo()方法：

 private List findUsingInfo(Class subscriberClass) {
        //从对象池中寻找FindState实例（数组的形式实现对象池）
        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); //找到方法后释放findState
    }

经过上面代码注释，对寻找订阅方法的步骤已经很清晰了，下面贴出getSubscriberInfo()和findUsingReflectionInSingleClass()两个方法：

 private SubscriberInfo getSubscriberInfo(FindState findState) {
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            //判断是否是需要寻找的具体类
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                return superclassInfo;
            }
        }
        //通过订阅信息索引进行查找
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

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();
            //对订阅方法的作用域进行判断
            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)) {
                    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");
            }
        }
    }

3.2、是如何进行订阅的？subscribe()

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;

        //通过订阅者和订阅方法创建一个订阅事件
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

        //根据eventType从缓存中获取subscriptions
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);

        //若缓存中没有，则添加到缓存
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

         //遍历订阅事件，根据优先级重新排序
        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;
            }
        }
      
        //这里根据订阅者查找EventType缓存
        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);
            }
        }
    }

上面的代码，就是整个的订阅过程了，比较关键的两个东西subscriptionsByEventType和typesBySubscriber，首先把订阅者和订阅方法封装进subscriptionsByEventType，当post事件时根据eventType查找具体的订阅者，然后进行处理。而typesBySubscriber存放的订阅者，在解注册时根据订阅者查找对应的eventType。在最后，会判断是否是粘性事件，如果是，则立刻进行处理。

  private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {    
            //post事件是最终也调用这个方法，所以在下一步进行分析
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }

4、发送事件 post()

public void post(Object event) {
        //每个线程都有一个提交事件的状态
        PostingThreadState postingState = currentPostingThreadState.get();
        List