Android事件总线框架设计：EventBus3.0源码详解与架构分析(下)

1.粘性事件

粘性事件就是在发送事件以后再订阅该事件也能收到该事件，跟黏性广播相似。

首先看下粘性事件的发布方式：

EventBus.getDefault().postSticky("hello, eventbus!");

咱们看下发布粘性事件方法的源码

private final Map<Class<?>, Object> stickyEvents;

    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            // 先将事件缓存在stickyEvents中
            // stickyEvents是一个Map，key是事件类型，value是事件
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        // 而后把事件发布出去，若是没有注册，不会执行订阅事件方法
        post(event);
    }

postSticky方法主要作了两件事情，先是把事件缓存在stickyEvents中，而后经过post方法把事件发布出去，这个方法以前已经分析过，这里不在分析了。

发布完粘性事件后，当订阅粘性事件方法，完成注册后就会当即执行。核心的注册流程是以前分析的register方法，其中subscribe方法一段代码就是处理粘性事件

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        // ......

        // 若是在订阅事件方法时，@Subscribe注解中的sticky设置为true，表明粘性事件
        if (subscriberMethod.sticky) {
            // eventInheritance默认为true，表明继承关系事件也会被执行
            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);
            }
        }
    }

能够看出，处理粘性事件是在注册时，遍历stickyEvents，而后交给checkPostStickyEventToSubscription处理

private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)
            // --> Strange corner case, which we don't take care of here.
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }

checkPostStickyEventToSubscription方法最终调用线程切换方法postToSubscription，由它完成事件的处理。

2.Subscriber Index

前面分析EventBus注册时，默认实现是经过反射技术查找注册类中全部的订阅事件的方法，若是当前注册类中有不少订阅事件方法，经过反射技术就会影响运行时性能。因此在EventBus3.0经过APT(注解处理器)技术在编译器就查找全部订阅事件方法，生成一个辅助的索引SUBSCRIBER_INDEX保存全部的订阅方法。

要在项目编译时查找订阅事件的方法信息，首先要在 app 的 build.gradle 中加入以下配置：

android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                // APT 设置的参数，指定辅助索引类名和包名
                arguments = [ eventBusIndex : 'com.example.myapp.MyEventBusIndex' ]
            }
        }
    }
}

dependencies {
    implementation 'org.greenrobot:eventbus:3.1.1'
    // 引入注解处理器
    annotationProcessor 'org.greenrobot:eventbus-annotation-processor:3.1.1'
}

而后在项目的 Application 中添加以下配置，以生成一个默认的 EventBus 单例：

EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();

EventBus eventBus = EventBus.getDefault();

编译后，就会生成MyEventBusIndex类，源码以下：

public class MyEventBusIndex implements SubscriberInfoIndex {
    private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;

    static {
        SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();

        putIndex(new SimpleSubscriberInfo(com.example.eventbus.demo.MainActivity.class, true,
                new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("onMessageEventMain", com.example.eventbus.demo.MessageEvent.class,
                    ThreadMode.MAIN, 0, true),
        }));

        putIndex(new SimpleSubscriberInfo(com.example.eventbus.demo.TestActivity.class, true,
                new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("onMessageEventMainForTest", com.example.eventbus.demo.MessageEvent.class,
                    ThreadMode.MAIN, 0, true),
        }));

    }

    private static void putIndex(SubscriberInfo info) {
        SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
    }

    @Override
    public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {
        SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
        if (info != null) {
            return info;
        } else {
            return null;
        }
    }
}

其中SUBSCRIBER_INDEX是一个Map，保存当前注册类的Class和订阅事件方法信息。

咱们先从使用MyEventBusIndex这个索引类方式入手

EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();

调用EventBus的builder方法建立一个EventBusBuilder对象，而后调用它的addIndex方法，添加索引类

public EventBusBuilder addIndex(SubscriberInfoIndex index) {
        if (subscriberInfoIndexes == null) {
            subscriberInfoIndexes = new ArrayList<>();
        }
        subscriberInfoIndexes.add(index);
        return this;
    }

从上面代码能够看出，把生成的索引类添加到subscriberInfoIndexes集合中，而后调用installDefaultEventBus方法，建立默认的EventBus实例

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

    public EventBus build() {
        // this表明是EventBusBuilder实例，这样EventBus就能够拿到subscriberInfoIndexes集合
        return new EventBus(this);
    }

其中subscriberInfoIndexes集合经过EventBus构造传给EventBus

EventBus(EventBusBuilder builder) {
        // ...
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        // ...
    }

以前在分析注册流程的时，其中findUsingInfo方法就会处理这个索引类，咱们在来看下源码

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        // FindState
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 若是没有使用APT(注解处理器)生成订阅方法索引，返回null，则进入else语句中
            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);
            }
            // 从父类中继续查找，直到父类为null
            findState.moveToSuperclass();
        }
        // 返回注册类中全部的订阅方法，并释放findState中状态，同时把findState对象放回缓存池中
        return getMethodsAndRelease(findState);
    }

当咱们使用APT生成了并使用了索引类的时，就不会经过反射技术查找注册类中全部的订阅事件方法了。

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;
            }
        }
        // subscriberInfoIndexes就是经过addIndex方法添加索引类集合
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

subscriberInfoIndexes集合就是经过addIndex方法建立的，并保存了索引类实例MyEventBusIndex。

使用Subscriber Index，避免了经过反射技术处理，提升了性能。

3.AsyncExecutor

AsyncExecutor与线程池相似，可是能够处理运行异常。

public static AsyncExecutor create() {
        return new Builder().build();
    }

经过AsyncExecutor静态方法create能够建立一个AsyncExecutor实例对象，而后调用它的execute方法执行任务

public void execute(final RunnableEx runnable) {
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    runnable.run();
                } catch (Exception e) {
                    Object event;
                    try {
                        event = failureEventConstructor.newInstance(e);
                    } catch (Exception e1) {
                        eventBus.getLogger().log(Level.SEVERE, "Original exception:", e);
                        throw new RuntimeException("Could not create failure event", e1);
                    }
                    if (event instanceof HasExecutionScope) {
                        ((HasExecutionScope) event).setExecutionScope(scope);
                    }
                    eventBus.post(event);
                }
            }
        });
    }

当发生异常时，会发布ThrowableFailureEvent事件，咱们能够订阅该事件进行相应的处理。execute方法接收的参数是RunnableEx对象

public interface RunnableEx {
        void run() throws Exception;
    }

RunnableEx中的run方法是能够抛出异常的。

咱们能够根据AsyncExecutor另外一个静态方法builder，修改默认的线程池threadPool，失败的事件类型failureEventType

// AsyncExecutor.java源码
    public static Builder builder() {
        return new Builder();
    }

   public static class Builder {
        private Executor threadPool;
        private Class<?> failureEventType;

        public Builder threadPool(Executor threadPool) {
            this.threadPool = threadPool;
            return this;
        }

        public Builder failureEventType(Class<?> failureEventType) {
            this.failureEventType = failureEventType;
            return this;
        }
   }

EventBus到此全部的源码已经分析完了～～～