[搞定开源]第五篇 EventBus3.1.1原理

Android开源项目原理系列
[搞定开源] 第一篇 okhttp 3.10原理
[搞定开源] 第二篇 okio 1.14原理
[搞定开源] 第三篇 retrofit 2.4.0与设计模式
[搞定开源] 第四篇 手动实现RxJava2线程切换

EventBus是Android的发布订阅开源库，优势和使用方法不用说了，简单过一下源码，了解核心原理。

当前EventBus最新版本是3.1.1，和前代相比，方法名可以自定义，新增注解支持。

EventBus构造函数

优秀开源库的基本特征是，常用功能用一个入口类就可以玩转，EventBus也是。

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

获取EventBus对象常规使用getDefault，典型的Double Check获取单例。如果有特别需求，可以通过EventBusBuilder，典型的建造者模式。

EventBus构造函数创建了十多个对象，关注其中的：

EventBus(EventBusBuilder builder) {
    logger = builder.getLogger();
    //...
    mainThreadSupport = builder.getMainThreadSupport();
    mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
    backgroundPoster = new BackgroundPoster(this);
    //...
}

Log

EventBus的日志打印使用Logger接口，已经实现了：

• AndroidLogger
• JavaLogger
• SystemOutLogger

static final boolean ANDROID_LOG_AVAILABLE;

static {
    boolean android = false;
    try {
        android = Class.forName("android.util.Log") != null;
    } catch (ClassNotFoundException e) {
        // OK
    }
    ANDROID_LOG_AVAILABLE = android;
}

public static boolean isAndroidLogAvailable() {
    return ANDROID_LOG_AVAILABLE;
}

对于Android，直接尝试获取Log类，同时用来判断当前是否Android。

获取Android的UI线程

EventBus如何让事件执行在Android的UI线程呢？

MainThreadSupport getMainThreadSupport() {
    if (mainThreadSupport != null) {
        return mainThreadSupport;
    } else if (Logger.AndroidLogger.isAndroidLogAvailable()) {
        Object looperOrNull = getAndroidMainLooperOrNull();
        return looperOrNull == null ? null :
                new MainThreadSupport.AndroidHandlerMainThreadSupport((Looper) looperOrNull);
    } else {
        return null;
    }
}

Object getAndroidMainLooperOrNull() {
    try {
        return Looper.getMainLooper();
    } catch (RuntimeException e) {
        // Not really a functional Android (e.g. "Stub!" maven dependencies)
        return null;
    }
}

这里用到了上面判断Android的方法，如果是，创建AndroidHandlerMainThreadSupport，保存了Looper.getMainLooper()。很熟悉吧，这就是Android的UI线程Looper。

Poster

EventBus的event可以指定运行在UI线程或者后台线程，靠的就是Poster，下文会说到，透露一丢丢：

• UI线程：MainLooper
• 后台线程：线程池

注册/取消注册

想要接收EventBus发送的事件，对象必须先注册，停止接收时取消注册。注册过程，本质是通知EventBus查找对象中的订阅方法。

Subscribe注解

@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent4Main(MsgEvent event) {}

EventBus3之后，订阅方法名改为自定义，通过注解描述。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;
    boolean sticky() default false;
    int priority() default 0;
}

除了基础的ThreadMode线程模型，还可以定义粘性事件和优先级。

注解信息，在注册过程最后由SubscriberMethod类描述。

注册过程

public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

注册时传入订阅对象，两部操作：

1. 分析订阅对象的类，SubscriberMethodFinder从中查找订阅方法，包装为SubscriberMethod。
2. 调用subscribe，数据转化为EventBus内部的两个Map。

List

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

    //2
    if (ignoreGeneratedIndex) {
        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. 查找目标类的订阅方法前，先查找缓存METHOD_CACHE，用的是ConcurrentHashMap，因为要处理多线程。

Map, List> METHOD_CACHE = new ConcurrentHashMap<>()

2. 默认创建的EventBus对象ignoreGeneratedIndex=false，先看findUsingInfo
3. 获取List成功后，保存在缓存METHOD_CACHE

SubscriberMethodFinder.FindState

上面第二步重点是使用SubscriberMethodFinder的内部类FindState执行查找过程：

private List findUsingInfo(Class subscriberClass) {
    //1
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    //2
    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 {
            //3
            findUsingReflectionInSingleClass(findState);
        }
        //4
        findState.moveToSuperclass();
    }
    //5
    return getMethodsAndRelease(findState);
}

第一步是调用prepareFindState获取FindState：

private static final int POOL_SIZE = 4;
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;
                return state;
            }
        }
    }
    return new FindState();
}

FindState的创建不是直接new，而是尝试从FIND_STATE_POOL中获取(最多保存4个)，目测是享元模式，没有才new对象。

第二步进入循环，从当前类开始，遍历父类查找订阅方法。

这里涉及EventBus3新特性，运行时反射查找方法当然会慢点，可以使用Subscriber Index在编译期操作加速，具体不展开，直接看else部分。

第三步的findUsingReflectionInSingleClass，使用反射查找，细节不用展开。

第四步将当前查找目标切换到父类，继续循环查找。

private List getMethodsAndRelease(FindState findState) {
    List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
    findState.recycle();
    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;
}

第五步清理FindState，放回FIND_STATE_POOL，下次继续利用。

subscribe

register函数对每个SubscriberMethod执行subscribe，注意这里synchronized当前EventBus对象。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    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;
        }
    }

    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);

    //... 粘性事件略
}

subscribe不外乎是对数据的挪腾，目的是构建subscriptionsByEventType和typesBySubscriber两个Map：

subscriptionsByEventType

private final Map, CopyOnWriteArrayList> subscriptionsByEventType;

Subscription包装了订阅对象和订阅方法，因此Map的key/value对应如下：

event类型 -> List<订阅对象,订阅方法>

表示了event由哪些对象的哪个方法订阅了。

typesBySubscriber

private final Map>> typesBySubscriber;

typesBySubscriber简单些，表示订阅对象订阅了哪些event类型：

订阅对象 -> List

取消注册

public synchronized void unregister(Object subscriber) {
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        for (Class eventType : subscribedTypes) {
            unsubscribeByEventType(subscriber, eventType);
        }
        typesBySubscriber.remove(subscriber);
    } else {
        logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}

取消注册的逻辑很简单，将当前订阅者的信息从subscriptionsByEventType和typesBySubscriber中移除。

发送

PostingThreadState(每个线程一份)

EventBus发送event调用post方法，首先来认识EventBus核心的内部类PostingThreadState。

private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
    @Override
    protected PostingThreadState initialValue() {
        return new PostingThreadState();
    }
};
    
final static class PostingThreadState {
    final List