Android EventBus学习笔记

逃离我推掉我的手 2022-07-13 10:46 246阅读 0赞

[EventBus][]是Android的一个事件总线库，它作为发布/订阅框架为开发者提供便利。它有很多[优势][Link 1]：使用起来很简洁，高性能，配置起来很简单等等（相比于BroadCastReceiver）。在EventBus3.0版本，事件的订阅已经从方法名换成了注解的方式。因为我在自己的项目里使用了EventBus库（3.0版本），所以准备在这里做一个学习笔记，记录下自己的心得体会（借鉴了网上前辈的文章，在文末给出了链接），因为一个库的代码逻辑可能会因为条件而产生分叉，我这里就默认分析我们采用default变量配置而走的逻辑以及代码运行的主逻辑（部分分析会放在代码的注释里）。

## 类关系图 ##

引用自[EventBus 源码解析][EventBus 1]  
![这里写图片描述][class-relation.png]

## 获取EventBus实例 ##

EventBusJsonObject eventBusJsonObject = new EventBusJsonObject();
        EventBus.getDefault().post(eventBusJsonObject);

从上面的代码可以读出，我们用EventBus.getDefault()获取到了对象。

\\org\\greenrobot\\eventbus\\EventBus.java

/** Convenience singleton for apps using a process-wide EventBus instance. */
        public static EventBus getDefault() {
            if (defaultInstance == null) {
                synchronized (EventBus.class) {
                    if (defaultInstance == null) {
                        defaultInstance = new EventBus();
                    }
                }
            }
            return defaultInstance;
        }

这是**单例模式**的经典写法，其中synchronized我在之前的文章也做了笔记。在这里是双重校验的单例，确保在不同线程中也只存在一个EvenBus的实例通过new EventBus()创建了对象。代码如下：

\\org\\greenrobot\\eventbus\\EventBus.java

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();//我们通常使用的就是通过这种默认方式初始化的对象
    
        /** * Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a * central bus, consider {@link #getDefault()}. */
        public EventBus() {
       //被单例所调用
            this(DEFAULT_BUILDER);
        }
    
        EventBus(EventBusBuilder builder) {
            subscriptionsByEventType = new HashMap<>();//以event(即事件类)为key，以订阅列表(Subscription)为value，事件发送之后，在这里寻找订阅者,而Subscription又是一个CopyOnWriteArrayList，这是一个线程安全的容器。Subscription是一个封装类，封装了订阅者、订阅方法这两个类。CopyOnWriteArrayList是一个ArrayList线程安全的变体。当数组内容有所变化时，拷贝一份新的出来（加锁），在新对象上进行修改操作，完成后把新对象引用赋值给array属性。每发生一次改变，就需要复制一份数据，这样复制是需要一定开销的，所以CopyOnWriteArrayList适合读操作远大于修改操作的情况中。
            typesBySubscriber = new HashMap<>();//以订阅者类为key，以event事件队列为value，在进行register或unregister操作的时候，会操作这个map。
            stickyEvents = new ConcurrentHashMap<>();//粘性事件（暂不讨论）
    
            mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
            backgroundPoster = new BackgroundPoster(this);
            asyncPoster = new AsyncPoster(this);
    
            indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
            //后半部分用了DEFAULT_BUILDER来直接初始化类的成员变量，如果我们不用建造者去初始化对象而是直接使用单例，那么使用的就是默认的单例对象。
            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;
        }

可以看出DEFAULT\_BUILDER初始化了很多属性， 以及一些变量的初始化也是放在构造这里（例如asyncPoster = new AsyncPoster(this);）。

### 建造者模式 ###

除单例模式之外，我们可以通过建造者帮我们建造具有不同功能的EventBus。  
\\org\\greenrobot\\eventbus\\EventBus.java

public static EventBusBuilder builder() {
            return new EventBusBuilder();
        }

\\org.greenrobot.eventbus\\EventBusBuilder.java 文件则是build的属性所在，如果通过建造者模式来建造对象，则是如下：

EventBus eventBus = EventBus.builder()
            .eventInheritance(false)
            .sendNoSubscriberEvent(true)
            .build();

每一个EventBus在事件处理方面，都有一个自己独立的范围，因此可以存在多个EventBus实例。除单例获取对象之外，我们可以通过建造者帮我们建造具有不同功能的EventBus。

下面是EventBusBuilder：  
\\org.greenrobot.eventbus\\EventBusBuilder.java

/** * Creates EventBus instances with custom parameters and also allows to install a custom default EventBus instance. * Create a new builder using {@link EventBus#builder()}. */
    public class EventBusBuilder { 
        private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
    
        boolean logSubscriberExceptions = true;//是否允许显示logSubscriberExceptions异常信息
        boolean logNoSubscriberMessages = true;//是否允许显示当前事件没有订阅者信息，后面几个boolean值都是默认给好的，如ignoreGeneratedIndex给的就是false，在我们初始的单例里就是false
        boolean sendSubscriberExceptionEvent = true;
        boolean sendNoSubscriberEvent = true;
        boolean throwSubscriberException;
        boolean eventInheritance = true;
        boolean ignoreGeneratedIndex;
        boolean strictMethodVerification;
        ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;//ExecutorService就是线程池。ExecutorService是线程池的一个服务，可以随时关闭线程池，是继承Executor的。Executors是个工厂类，专门创建各种线程池。初始的线程池是newCachedThreadPool线程池，先查看池中有没有以前建立的线程，如果有，就重用。如果没有，就建一个新的线程加入池中。粘性事件用到了。
        List<Class<?>> skipMethodVerificationForClasses;
        List<SubscriberInfoIndex> subscriberInfoIndexes;//初始化的时候为null
    
        EventBusBuilder() {
        }
    
        /** Default: true */
        public EventBusBuilder logSubscriberExceptions(boolean logSubscriberExceptions) {
            this.logSubscriberExceptions = logSubscriberExceptions;
            return this;
        }
    
        /** Default: true */
        public EventBusBuilder logNoSubscriberMessages(boolean logNoSubscriberMessages) {
            this.logNoSubscriberMessages = logNoSubscriberMessages;
            return this;
        }
    
        /** Default: true */
        public EventBusBuilder sendSubscriberExceptionEvent(boolean sendSubscriberExceptionEvent) {
            this.sendSubscriberExceptionEvent = sendSubscriberExceptionEvent;
            return this;
        }
    
        /** Default: true */
        public EventBusBuilder sendNoSubscriberEvent(boolean sendNoSubscriberEvent) {
            this.sendNoSubscriberEvent = sendNoSubscriberEvent;
            return this;
        }
    
        /** * Fails if an subscriber throws an exception (default: false). * <p/> * Tip: Use this with BuildConfig.DEBUG to let the app crash in DEBUG mode (only). This way, you won't miss * exceptions during development. */
        public EventBusBuilder throwSubscriberException(boolean throwSubscriberException) {
            this.throwSubscriberException = throwSubscriberException;
            return this;
        }
    
        /** * By default, EventBus considers the event class hierarchy (subscribers to super classes will be notified). * Switching this feature off will improve posting of events. For simple event classes extending Object directly, * we measured a speed up of 20% for event posting. For more complex event hierarchies, the speed up should be * >20%. * <p/> * However, keep in mind that event posting usually consumes just a small proportion of CPU time inside an app, * unless it is posting at high rates, e.g. hundreds/thousands of events per second. */
        public EventBusBuilder eventInheritance(boolean eventInheritance) {
            this.eventInheritance = eventInheritance;
            return this;
        }
    
    
        /** * Provide a custom thread pool to EventBus used for async and background event delivery. This is an advanced * setting to that can break things: ensure the given ExecutorService won't get stuck to avoid undefined behavior. */
        public EventBusBuilder executorService(ExecutorService executorService) {
            this.executorService = executorService;
            return this;
        }
    
        /** * Method name verification is done for methods starting with onEvent to avoid typos; using this method you can * exclude subscriber classes from this check. Also disables checks for method modifiers (public, not static nor * abstract). */
        public EventBusBuilder skipMethodVerificationFor(Class<?> clazz) {
            if (skipMethodVerificationForClasses == null) {
                skipMethodVerificationForClasses = new ArrayList<>();
            }
            skipMethodVerificationForClasses.add(clazz);
            return this;
        }
    
        /** Forces the use of reflection even if there's a generated index (default: false). */
        public EventBusBuilder ignoreGeneratedIndex(boolean ignoreGeneratedIndex) {
            this.ignoreGeneratedIndex = ignoreGeneratedIndex;
            return this;
        }
    
        /** Enables strict method verification (default: false). */
        public EventBusBuilder strictMethodVerification(boolean strictMethodVerification) {
            this.strictMethodVerification = strictMethodVerification;
            return this;
        }
    
        /** Adds an index generated by EventBus' annotation preprocessor. */
        public EventBusBuilder addIndex(SubscriberInfoIndex index) {
            if(subscriberInfoIndexes == null) {
                subscriberInfoIndexes = new ArrayList<>();
            }
            subscriberInfoIndexes.add(index);
            return this;
        }
    
        /** * Installs the default EventBus returned by {@link EventBus#getDefault()} using this builders' values. Must be * done only once before the first usage of the default EventBus. * * @throws EventBusException if there's already a default EventBus instance in place */
        public EventBus installDefaultEventBus() {
            synchronized (EventBus.class) {
                if (EventBus.defaultInstance != null) {
                    throw new EventBusException("Default instance already exists." +
                            " It may be only set once before it's used the first time to ensure consistent behavior.");
                }
                EventBus.defaultInstance = build();
                return EventBus.defaultInstance;
            }
        }
    
        /** Builds an EventBus based on the current configuration. */
        public EventBus build() {
            return new EventBus(this);
        }
    
    }

## register方法 ##

/** * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they * are no longer interested in receiving events. * <p/> * Subscribers have event handling methods that must be annotated by {@link Subscribe}. * The {@link Subscribe} annotation also allows configuration like {@link * ThreadMode} and priority. */
        public void register(Object subscriber) {
            Class<?> subscriberClass = subscriber.getClass();//获取了订阅者类的class
            /** <?> is a shorthand for <? extends Object>, it's also known as an unbounded wildcard. So you can specify any type of object in your generic. For example the List class is declared as List<?>, because it can be a list of anything you want. <?>解释 */
            List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//获取subscribe的方法。把订阅方法找出来了，并保存在集合中。返回一个SubscriberMethod对象的list，SubscriberMethod里包含了这个方法的Method对象，以及将来响应订阅是在哪个线程的ThreadMode，以及订阅的事件类型eventType（参数类型），以及优先级priority,以及是否接收粘性sticky事件的boolean值。
            synchronized (this) {
                for (SubscriberMethod subscriberMethod : subscriberMethods) {
                    subscribe(subscriber, subscriberMethod);//订阅
                }
            }
        }

可以看出，执行findSubscriberMethods方法找出了一个方法集合，findSubscriberMethods如下：

/org.greenrobot.eventbus/SubscriberMethodFinder.java

## findSubscriberMethods方法 ##

private static final Map<Class<?>, List<SubscriberMethod>> METHOD_CACHE = new ConcurrentHashMap<>(); List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) { List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass); if (subscriberMethods != null) { //从缓存中取出subscriberMethodss，如果有则直接返回该已取得的方法,这样可以提高效率 return subscriberMethods; } if (ignoreGeneratedIndex) { //初始值为false，当我们使用自带的单例的时候。ignoreGeneratedIndex表示是否忽视注解器生成的类 subscriberMethods = findUsingReflection(subscriberClass); } else { subscriberMethods = findUsingInfo(subscriberClass); //从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息。 } 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);//将获取的subscriberMeyhods放入缓存中 return subscriberMethods; } }

findSubscriberMethods从字面意思上理解就是找到订阅方法的意思。METHOD\_CACHE作为缓存，key是subscriberClass。ignoreGeneratedIndex根据代码追踪可知其值是false。那么执行的应该是findUsingInfo函数。

## findUsingInfo方法 ##

/org.greenrobot.eventbus/SubscriberMethodFinder.java

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) { 
            FindState findState = prepareFindState();//准备一个FindState，该FindState保存了订阅者类的信息，从复用池取出，如果复用池中没有空闲的FindState对象，那么就新建一个。
            findState.initForSubscriber(subscriberClass);//对FindState初始化，findState.subscriberInfo是null。跟上一个步骤不同，上一步是复用，这一步是数据的加载。
            while (findState.clazz != null) {
                findState.subscriberInfo = getSubscriberInfo(findState);//获得订阅者的信息，一开始会返回null
                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);
        }

initForSubscriber初始化了FindState 对象。getSubscriberInfo根据我们builder来看（subscriberInfoIndexes是0，findState.subscriberInfo一开始是null，getSubscriberInfo函数因此返回null，在这里就不贴出来了），返回的一般是null（通常情况），所以我会自然而然地执行到findUsingReflectionInSingleClass方法。

## prepareFindState ##

private static final FindState[] FIND_STATE_POOL = new FindState[POOL_SIZE];
    
        private FindState prepareFindState() {
            synchronized (FIND_STATE_POOL) {
                for (int i = 0; i < POOL_SIZE; i++) {
                    FindState state = FIND_STATE_POOL[i];
                    if (state != null) {
                        FIND_STATE_POOL[i] = null;//复用FindState，FIND_STATE_POOL是一个复用池。
                        return state;
                    }
                }
            }
            return new FindState();
        }

## FindState ##

static class FindState {
            final List<SubscriberMethod> subscriberMethods = new ArrayList<>();//订阅方法的列表
            final Map<Class, Object> anyMethodByEventType = new HashMap<>();
            final Map<String, Class> subscriberClassByMethodKey = new HashMap<>(); //以method的名字生成一个method为key，以订阅者类为value
            final StringBuilder methodKeyBuilder = new StringBuilder(128);
    
            Class<?> subscriberClass;
            Class<?> clazz;
            boolean skipSuperClasses;
            SubscriberInfo subscriberInfo;
    
            void initForSubscriber(Class<?> subscriberClass) {
                this.subscriberClass = clazz = subscriberClass;
                skipSuperClasses = false;
                subscriberInfo = null;
            }
    
            void recycle() {
                subscriberMethods.clear();
                anyMethodByEventType.clear();
                subscriberClassByMethodKey.clear();
                methodKeyBuilder.setLength(0);
                subscriberClass = null;
                clazz = null;
                skipSuperClasses = false;
                subscriberInfo = null;
            }
    
            boolean checkAdd(Method method, Class<?> eventType) {
                // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
                // Usually a subscriber doesn't have methods listening to the same event type.
                Object existing = anyMethodByEventType.put(eventType, method);
                if (existing == null) {
                    return true;
                } else {
                    if (existing instanceof Method) {
                        if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                            // Paranoia check
                            throw new IllegalStateException();
                        }
                        // Put any non-Method object to "consume" the existing Method
                        anyMethodByEventType.put(eventType, this);
                    }
                    return checkAddWithMethodSignature(method, eventType);
                }
            }
    
            private boolean checkAddWithMethodSignature(Method method, Class<?> eventType) {
                methodKeyBuilder.setLength(0);
                methodKeyBuilder.append(method.getName());
                methodKeyBuilder.append('>').append(eventType.getName());
    
                String methodKey = methodKeyBuilder.toString();
                Class<?> methodClass = method.getDeclaringClass();
                Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
                if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                    // Only add if not already found in a sub class
                    return true;
                } else {
                    // Revert the put, old class is further down the class hierarchy
                    subscriberClassByMethodKey.put(methodKey, methodClassOld);
                    return false;
                }
            }
    
            void moveToSuperclass() {
                if (skipSuperClasses) {
                    clazz = null;
                } else {
                    clazz = clazz.getSuperclass();
                    String clazzName = clazz.getName();
                    /** Skip system classes, this just degrades performance. */
                    if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") || clazzName.startsWith("android.")) {
                        clazz = null;
                    }
                }
            }
        }

## findUsingReflectionInSingleClass ##

在这个方法内部，利用反射的方式，对订阅者类进行扫描，找出订阅方法，并用FindState类中的进行保存。

private void findUsingReflectionInSingleClass(FindState findState) {
            Method[] methods;
            try {
                // This is faster than getMethods, especially when subscribers are fat classes like Activities
                /*getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。 getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法。*/
                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) {
       //PUBLIC是0x1，(modifiers & Modifier.PUBLIC) != 0的含义是方法是public的。
                    Class<?>[] parameterTypes = method.getParameterTypes();//获取方法的参数类型
                    if (parameterTypes.length == 1) {
       //如果参数个数为一个，则继续，post的时候只支持一个参数
                        Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);//获取该方法的@Subscribe注解
                        if (subscribeAnnotation != null) {
       //进入条件模块的是注解Subscribe类的方法。
                            Class<?> eventType = parameterTypes[0]; //参数类型是事件类型
                            if (findState.checkAdd(method, eventType)) {
       //当这个函数经过下面的讲解返回true的时候
                                ThreadMode threadMode = subscribeAnnotation.threadMode();//从注解中提取threadMode，Subscribe类中已经定义了
                                findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                        subscribeAnnotation.priority(), subscribeAnnotation.sticky()));//新建一个SubscriberMethod对象，并添加到findState的subscriberMethods这个集合内。
                            }
                        }
                    } 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)) { // 方法不是 public 则抛出异常 
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException(methodName +
                            " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
                }
            }
        }

根据上面代码中的注释，我们会运行到findState.checkAdd(method, eventType)这一行代码。

## checkAdd ##

boolean checkAdd(Method method, Class<?> eventType) { // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required. // Usually a subscriber doesn't have methods listening to the same event type. Object existing = anyMethodByEventType.put(eventType, method);//外部是循环 if (existing == null) {//根据eventType来判断是否有多个方法订阅该事件 return true;//没有重复的旧值，直接返回true } else {//别的方法订阅了eventType if (existing instanceof Method) { if (!checkAddWithMethodSignature((Method) existing, eventType)) { // Paranoia check throw new IllegalStateException(); } // Put any non-Method object to "consume" the existing Method anyMethodByEventType.put(eventType, this);
                    }
                    return checkAddWithMethodSignature(method, eventType);
                }
            }

如果别的方法也订阅了当前eventType，在这里会执行checkAddWithMethodSignature方法。

## checkAddWithMethodSignature ##

private boolean checkAddWithMethodSignature(Method method, Class<?> eventType) {根据完整的方法(包括方法名字以及参数名字)来判断
                methodKeyBuilder.setLength(0);
                methodKeyBuilder.append(method.getName());
                methodKeyBuilder.append('>').append(eventType.getName());
    
                String methodKey = methodKeyBuilder.toString();//由方法名与事件名（参数类型）拼起来
                Class<?> methodClass = method.getDeclaringClass();
                Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
                if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
       //判断methodClassOld是否是methodClass或者是它的父类
                    // Only add if not already found in a sub class
                    return true;
                } else {
                    // Revert the put, old class is further down the class hierarchy
                    subscriberClassByMethodKey.put(methodKey, methodClassOld);
                    return false;
                }
            }

## checkAdd和checkAddWithMethodSignature的作用 ##

引用自[http://www.jianshu.com/p/bda4ed3017ba][http_www.jianshu.com_p_bda4ed3017ba]  
例子1：比如一个类有多个订阅方法，方法名不同，但它们的**参数类型**都是相同的，那么遍历这些方法的时候，会多次调用到checkAdd方法，由于existing不为null，那么会进而调用checkAddWithMethodSignature方法。但是由于每个方法的名字都不同，因此methodClassOld会一直为null，因此都会返回true。也就是说，**允许一个类有多个参数相同的订阅方法**。

例子2：类B继承自类A，而每个类都是有相同订阅方法，换句话说，类B的订阅方法继承并重写自类A，它们都有着一样的方法签名。方法的遍历会从子类开始，即B类，在checkAddWithMethodSignature方法中，methodClassOld为null，那么B类的订阅方法会被添加到列表中。接着，向上找到类A的订阅方法，由于methodClassOld不为null而且显然类B不是类A的父类，methodClassOld.isAssignableFrom(methodClass)也会返回false，那么会返回false。也就是说，**子类继承并重写了父类的订阅方法，那么只会把子类的订阅方法添加到订阅者列表，父类的方法会忽略**。

当上面函数结束后，我们可以回溯到findSubscriberMethods方法的getMethodsAndRelease步骤。

## getMethodsAndRelease ##

private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
            List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);//从findState获取subscriberMethods，放进新的ArrayList
            findState.recycle();//把findState回收，清空其中的垃圾数据
            synchronized (FIND_STATE_POOL) {
                for (int i = 0; i < POOL_SIZE; i++) {
                    if (FIND_STATE_POOL[i] == null) {
                        FIND_STATE_POOL[i] = findState;
                        break;
                    }
                }
            }
            return subscriberMethods;//成功取到上面一系列步骤找到的当前类的注册函数
        }

该函数执行完之后，又回溯到了register方法，执行subscribe函数。

## subscribe ##

看上文的register方法，findSubscriberMethods找到了我们当前对象的订阅方法。然后开始遍历每一个订阅方法，并调用subscribe(subscriber, subscriberMethod)方法。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
            Class<?> eventType = subscriberMethod.eventType;//取到方法的参数的类型
            Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//将subscriber和subscriberMethod封装成 Subscription对象。
            CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);//根据事件类型获取特定的 Subscription
            if (subscriptions == null) {
       //subscriptions == null时，说明该subscriber尚未注册该事件
                subscriptions = new CopyOnWriteArrayList<>();
                subscriptionsByEventType.put(eventType, subscriptions);
            } else {
                if (subscriptions.contains(newSubscription)) {
       //如果不为null，并且包含了这个subscription 那么说明该subscriber已经注册了该事件，抛出异常。
                    throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                            + eventType);
                }
            }
    
            int size = subscriptions.size();
            for (int i = 0; i <= size; i++) {
       //根据优先级来设置放进subscriptions的位置，优先级高的会先被通知；对subscriptions进行遍；因为add了一个元素，i 变为<= size；
                if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
       //如果一直遍历到subscriptions的末尾，也没有符合subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority条件的，那么新加的这个元素在i == size情况的时候就自动排在最后；其他的情况，当subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority的时候，newSubscription就占据了原来元素的位置
                    subscriptions.add(i, newSubscription);
                    break;
                }
            }
    
            List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);//根据subscriber来获取它的所有订阅事件
            if (subscribedEvents == null) {
                subscribedEvents = new ArrayList<>();
                typesBySubscriber.put(subscriber, subscribedEvents);//register的时候，把subscribedEvents放到typesBySubscriber里；相应地，在unregister的时候也会用到。
            }
            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<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);
                }
            }
        }

在该方法内，主要是实现订阅方法与事件直接的关联，即注册。

## 注册 ##

上面多数步骤都是注册的过程，函数跳转较多，逻辑层较深。

## unregister ##

与注册相对应的是注销。

/** Unregisters the given subscriber from all event classes. */
        public synchronized void unregister(Object subscriber) {
            List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);//根据当前的订阅者来获取它所订阅的所有事件
            if (subscribedTypes != null) {
                for (Class<?> eventType : subscribedTypes) {
       //遍历所有订阅的事件
                    unsubscribeByEventType(subscriber, eventType);
                }
                typesBySubscriber.remove(subscriber);//从typesBySubscriber中删除，对应上文register中subscribe中的add。
            } else {
                Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
            }
        }

遍历执行unsubscribeByEventType方法。

## unsubscribeByEventType ##

/** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
        private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
            List<Subscription> subscriptions = subscriptionsByEventType.get(eventType); //根据事件类型从subscriptionsByEventType中获取相应的 subscriptions 集合。
            if (subscriptions != null) {
                int size = subscriptions.size();
                for (int i = 0; i < size; i++) {
                    Subscription subscription = subscriptions.get(i);
                    if (subscription.subscriber == subscriber) {从subscriptionsByEventType.get(eventType)移除相应的数据
                        subscription.active = false;
                        subscriptions.remove(i);
                        i--;
                        size--;
                    }
                }
            }
        }

在unregister函数中， 直接移除了typesBySubscriber的相应数据；在unsubscribeByEventType中，移除了subscriptionsByEventType中响应的数据。注销流程相对于注册流程层级少了很多，注册流程主要逻辑集中于怎样找到订阅方法上并将其添加到相应的数据结构中，供post等方法调用。

## post方法 ##

然后是发送事件的逻辑：

/** Posts the given event to the event bus. */
        public void post(Object event) {
            PostingThreadState postingState = currentPostingThreadState.get();//currentPostingThreadState是一个ThreadLocal，这一步获取到当前线程的postingState。
            List<Object> eventQueue = postingState.eventQueue;//初始化当前线程的存放集合。
            eventQueue.add(event);//把事件加入到当前对象当前线程所属的postingState的队列中去。
    
            if (!postingState.isPosting) {
       //一开始初始化的时候都是false
                postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();//判断当前线程是否是主线程。
                postingState.isPosting = true;
                if (postingState.canceled) {
                    throw new EventBusException("Internal error. Abort state was not reset");
                }
                try {
                    while (!eventQueue.isEmpty()) {
       //只要队列不为空，就不断从队列中获取事件进行分发，这里是一个循环。
                        postSingleEvent(eventQueue.remove(0), postingState);
                    }
                } finally {
                    postingState.isPosting = false;
                    postingState.isMainThread = false;
                }
            }
        }

上面代码块的核心内容是在循环执行postSingleEvent代码。

## PostingThreadState ##

/** For ThreadLocal, much faster to set (and get multiple values). */
        final static class PostingThreadState {
            final List<Object> eventQueue = new ArrayList<Object>();
            boolean isPosting;
            boolean isMainThread;
            Subscription subscription;
            Object event;
            boolean canceled;
        }

PostingThreadState主要是封装了当前线程的信息，以及订阅者、订阅事件等。相应的变量会在post以及后续步骤的函数中用到。

## currentPostingThreadState ##

private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
            @Override
            protected PostingThreadState initialValue() {
                return new PostingThreadState();
            }
        };

currentPostingThreadState是一个ThreadLocal，而ThreadLocal是**每个线程独享**的，其数据别的线程是不能访问的，因此是线程安全的。

## postSingleEvent ##

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
            Class<?> eventClass = event.getClass();//返回对象的class
            boolean subscriptionFound = false;
            if (eventInheritance) {
       //该eventInheritance上面有提到，默认为true，在EventBusBuilder中初始化的，即EventBus会考虑事件的继承树。
                List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);//寻找所有超类和接口的类对象，代码就不贴了。
                int countTypes = eventTypes.size();//获取类对象的数量
                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) {
                    Log.d(TAG, "No subscribers registered for event " + eventClass);
                }
                if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                        eventClass != SubscriberExceptionEvent.class) {
                    post(new NoSubscriberEvent(this, event));
                }
            }
        }

由上面的代码和注释可以知道，主流程会运行到postSingleEventForEventType函数。

## postSingleEventForEventType ##

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
            CopyOnWriteArrayList<Subscription> subscriptions;
            synchronized (this) {
                subscriptions = subscriptionsByEventType.get(eventClass);//取到注册时候存入的subscriptionsByEventType中的数据，获取相应的subscriptions。
            }
            if (subscriptions != null && !subscriptions.isEmpty()) {
                for (Subscription subscription : subscriptions) {
       //进行遍历
                    postingState.event = event;
                    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;
        }

进一步调用了postToSubscription方法。

## postToSubscription ##

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
            switch (subscription.subscriberMethod.threadMode) {
                case POSTING://表示订阅方法运行在发送事件的线程。
                    invokeSubscriber(subscription, event);
                    break;
                case MAIN://表示订阅方法运行在UI线程，由于UI线程不能阻塞，因此当使用MAIN的时候，订阅方法不应该耗时过长。
                    if (isMainThread) {
       //前一步设置了isMainThread是否是主线程。
                        invokeSubscriber(subscription, event);
                    } else {
                        mainThreadPoster.enqueue(subscription, event);
                    }
                    break;
                case BACKGROUND://表示订阅方法运行在后台线程，如果发送的事件线程不是UI线程，那么就使用该线程；如果发送事件的线程是UI线程，那么新建一个后台线程来调用订阅方法。
                    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);
            }
        }

## mainThreadPoster.enqueue(subscription, event); ##

因为除了invokeSubscriber(subscription, event);直接调用，还有各种调用如backgroundPoster.enqueue(subscription, event);和 mainThreadPoster.enqueue(subscription, event)。  
这里拿mainThreadPoster.enqueue(subscription, event);举例子来分析。

org.greenrobot.eventbus.EventBus.java

private final HandlerPoster mainThreadPoster;
    
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
    
    mainThreadPoster.enqueue(subscription, event);

org.greenrobot.eventbus.HandlerPoster.java

## HandlerPoster ##

HandlerPoster类继承自Handler。

final class HandlerPoster extends Handler { 
    
        private final PendingPostQueue queue;
        private final int maxMillisInsideHandleMessage;
        private final EventBus eventBus;
        private boolean handlerActive;
    
        HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
            super(looper);
            this.eventBus = eventBus;
            this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
            queue = new PendingPostQueue();//事件队列，PendingPostQueue的代码不贴了
        }
    
        void enqueue(Subscription subscription, Object event) {
            PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);//获取PendingPost类中static队列的最后一个PendingPost（当队列为空时新建）对象。这个PendingPost对象由subscription和event赋值。
            synchronized (this) {
                queue.enqueue(pendingPost);
                if (!handlerActive) {
                    handlerActive = true;
                    if (!sendMessage(obtainMessage())) {
       //发送事件给handler，由下面的handleMessage处理。
                        throw new EventBusException("Could not send handler message");
                    }
                }
            }
        }
    
        @Override
        public void handleMessage(Message msg) {
            boolean rescheduled = false;
            try {
                long started = SystemClock.uptimeMillis();
                while (true) {
                    PendingPost pendingPost = queue.poll();
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                handlerActive = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);//利用反射的方式来调用订阅方法
                    long timeInMethod = SystemClock.uptimeMillis() - started;
                    if (timeInMethod >= maxMillisInsideHandleMessage) {
                        if (!sendMessage(obtainMessage())) {
                            throw new EventBusException("Could not send handler message");
                        }
                        rescheduled = true;
                        return;
                    }
                }
            } finally {
                handlerActive = rescheduled;
            }
        }
    }

可以看出，在主线程最终还是调用了eventBus.invokeSubscriber(pendingPost);，执行了相应的注册函数。

## invokeSubscriber ##

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

invokeSubscriber主要实现了利用反射的方式来调用订阅方法。

## 观察者模式 ##

观察者模式：定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。  
从整个EventBus可以看出，事件是被观察者，订阅者类是观察者，当事件出现或者发送变更的时候，会通过EventBus通知观察者，使得观察者的订阅方法能够被自动调用。

## 总结 ##

可以看出，EventBus基本是用Java的注解和反射相应的知识构建的（在调用注解方法的时候使用到了相应的线程切换，如handler等Android的知识）。  
当**注册**的时候，就是获取订阅类中的所有被订阅的方法名称和参数类型。并且把对应的关系存放到集合，把不符合各种条件的函数摒除（例如有两个参数的函数就不满足条件）。  
在源码中通过**注解**获取到方法的参数类型以及方法本身。并通过方法的参数类型进行存储。以方法的参数类型作为识别标志，所以对于方法的名称不像3.0之前的版本那样用onEvent开头了。

EventBus使用较为简单，让发布者和订阅者充分解耦。但是它的层级比较多，所以我在这里只是参照各位前辈和自己的一些想法做了个笔记，可能会较为凌乱，希望谅解~

> [Android EventBus实战 没听过你就out了][Android EventBus_ _out]  
> [Android EventBus源码解析 带你深入理解EventBus][Android EventBus_ _out]  
> [EventBus 3.0 源码分析][EventBus 3.0]  
> [EventBus 3.0初探: 入门使用及其使用 完全解析][EventBus 3.0_ _]  
> [EventBus 3.0进阶：源码及其设计模式 完全解析][http_www.jianshu.com_p_bda4ed3017ba]  
> [Android的线程池：ExecutorService和Executors简单介绍][Android_ExecutorService_Executors]  
> [juc系列-CopyOnWriteArrayList][juc_-CopyOnWriteArrayList]  
> [EventBus 3.0使用及源码分析][EventBus 3.0 1]  
> [EventBus 3.0 源码简要分析][EventBus 3.0 2]

[EventBus]: https://github.com/greenrobot/EventBus
[Link 1]: http://greenrobot.org/eventbus/features/
[EventBus 1]: http://a.codekk.com/detail/Android/Trinea/EventBus%20%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90
[class-relation.png]: /images/20220713/6961829f27814424a6042561c5156a66.png
[http_www.jianshu.com_p_bda4ed3017ba]: http://www.jianshu.com/p/bda4ed3017ba
[Android EventBus_ _out]: http://blog.csdn.net/lmj623565791/article/details/40920453
[EventBus 3.0]: http://www.jianshu.com/p/f057c460c77e
[EventBus 3.0_ _]: http://www.jianshu.com/p/acfe78296bb5
[Android_ExecutorService_Executors]: http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2013/0304/958.html
[juc_-CopyOnWriteArrayList]: http://www.jianshu.com/p/3b37531faa56
[EventBus 3.0 1]: http://blog.csdn.net/lvwenbo0107/article/details/51647776
[EventBus 3.0 2]: http://blog.csdn.net/yxhuang2008/article/details/52225586