EventBus源码分析

本文发表于KuTear's Blog,转载请注明

最简单的例子说起

先从一个简单的栗子出发，看看EventBus的功能是什么。

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EventBus.getDefault().register(this);
        findViewById(R.id.say_hello).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                EventBus.getDefault().post(new EventBean(1,"Hello"));
            }
        });
}

@Subscribe(threadMode = ThreadMode.MAIN) //在ui线程执行
public void onEvent(EventBean event) {
        System.out.println(Thread.currentThread().getName());
}

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

上面的代码是最简单的一个事件，当点击按钮之后回调onEvent()方法。下面就着重看看这个过程的实现。类似的代码我们见得很多，比如App存在一个UserManager,有一个用户状态的分发，很多类在这里注册了用户状态的监听回调，当用户登陆，所有的注册了监听的类都会收到这个消息。其实EventBus的实现也是类似的，只是不存在接口。
看看上面的代码，我们可能会对是怎样回调onEvent()感到一丝的困惑。下面进入源码的世界。

EventBus 源码分析

先看看一些有用的字段

    //K->方法参数的类型   V->K的所有父类的结合（包括本身） 用作缓存
    private static final Map, List>> eventTypesCache = new HashMap<>();
    //K->方法参数的类型   V->所有参数类型的K的订阅函数的集合  主要是消息发送使用
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    //K->注册的类，如Activity  V-> 注册类的注册函数的参数的集合  主要是注册/解绑使用
    private final Map>> typesBySubscriber;
    //粘性事件 K->发出的事件的参数类型  V->事件的值
    private final Map, Object> stickyEvents;

一切的开始-事件的订阅

//EventBus
public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        //获取该类的所有的能接受事件的函数，也就是上面说的`onEvent(...)`
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
}

如何才能找到注册的方法呢,这就要看看SubscriberMethodFinder的具体实现了.

//SubscriberMethodFinder
List findSubscriberMethods(Class subscriberClass) {
        //提升速度，优先重缓存中取,支持并发操作
        //声明为 Map, List> METHOD_CACHE = new ConcurrentHashMap<>();
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        if (ignoreGeneratedIndex) { //默认为false
            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 {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
}

private List findUsingInfo(Class subscriberClass) {
        //从复用池中取回一个FindState
        FindState findState = prepareFindState();
        //为findState设置clazz等参数
        findState.initForSubscriber(subscriberClass);
        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.clazz为刚刚clazz的父类
            findState.moveToSuperclass();
        }
        //获取findState.subscriberMethods
        return getMethodsAndRelease(findState);
}

再看findUsingReflectionInSingleClass()之前,线看看FindState的一部分实现

//FindState
static class FindState {
    //订阅者的方法的列表
    final List subscriberMethods = new ArrayList<>();
    //以EventType为key，method为value
    final Map anyMethodByEventType = new HashMap<>();
    //以method的名字生成一个methodKey为key，该method的类(订阅者)为value
        final Map subscriberClassByMethodKey = new HashMap<>();
        //构建methodKey的StringBuilder
    final StringBuilder methodKeyBuilder = new StringBuilder(128);
    //订阅者
    Class subscriberClass;
        //当前类
    Class clazz;
        //是否跳过父类
    boolean skipSuperClasses;
       //SubscriberInfo
    SubscriberInfo subscriberInfo;

    void initForSubscriber(Class subscriberClass) {
        //clazz为当前类
        this.subscriberClass = clazz = subscriberClass;
        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)) {
                //判断old是否为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;
            }
        }
}

Ok,下面看看findUsingReflectionInSingleClass()的实现吧.

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(); //方法的修饰符 public|protected|private|default(package)
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { //大体上就是要求public,非static|abstract
                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");
            }
        }
}

现在函数调用栈退回到了最开始的register(),接着看subscribe(...)方法。

// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType; //参数类型
        //将注册类和方法打包为Subscription
        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;
            }
        }
        //typesBySubscriber  K->注册的类，如Activity  V-> 注册类的注册函数的参数的集合
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //注册的时候判断是否有粘性事件，如有就执行咯
        if (subscriberMethod.sticky) {
            if (eventInheritance) {  //Default true
                // 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();
                    //判断eventType是否为candidateEventType的父类，即所有的子类都能收到消息
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        //发送消息，这里先不讲，在后面也会说的
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
}

上面注册的过程基本已经说完，下面将讲事件的发送过程。根据最上面的栗子，我们知道入口是post()函数，下面就入手post()函数。

事件的发送

//保证每个线程取得的PostingThreadState不同，但是相同线程取得的相同，本质就是HashMap
private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
};

final static class PostingThreadState {
        final List