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到此全部的源碼已經分析完了～～～