EventBus3.1源码分析

最新推荐文章于 2020-01-16 19:22:59 发布

jh352160

最新推荐文章于 2020-01-16 19:22:59 发布

阅读量164

点赞数

本文链接：https://blog.csdn.net/jh352160/article/details/79857039

版权

使用示例
EventBusgetDefaultregisterthis
EventBusgetDefaultpostnew MessageEventHello everyone
总结

这篇文章将会为大家梳理一下EventBus的基本流程，本人使用的版本号为3.1.1，为了方便阅读，文章中的源码部分将省略部分有关异常捕获与日志相关代码。

使用示例

首先，按照官方的文档来看看一个最简单的EventBus示例是什么样的：

第一步：定义消息实体类

public class MessageEvent {
    public final String message;

    public MessageEvent(String message) {
        this.message = message;
    }
}

第二步：使用注解创建订阅方法

@Subscribe
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}

第三步：注册与注销订阅（注意与生命周期的绑定）

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

第四步：发送通知消息

EventBus.getDefault().post(new MessageEvent("Hello everyone!"));

这样，一个简单的Demo就完成了，本文将以这个Demo为基础，分析订阅事件从注册到接收并执行都是如何实现的。

1.EventBus.getDefault().register(this);

EventBus.getDefault()

    static volatile EventBus defaultInstance;

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

获取EventBus的单例对象，很标准的单例模式，就不细说了。

EventBus.register(Object subscriber)

    public void register(Object subscriber) {
        //获取注册订阅的类的Class对象
        Class<?> subscriberClass = subscriber.getClass();
        //查找Class中带有Subscribe注解的方法列表
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

SubscriberMethodFinder.findSubscriberMethods(Class

    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        //METHOD_CACHE为ConcurrentHashMap<Class<?>, List<SubscriberMethod>>，作为方法解析的缓存使用
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        //如果取出的SubscriberMethod不为null，则说明该类已被加载过，那么跳过解析的步骤，直接返回上次解析的结果
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        //ignoreGeneratedIndex用来设置是否忽略使用Subscriber Index来帮助注解解析，默认设置为false
        //Subscriber Index为EventBus3.0中出现的新特性，在build期间生成，以此增加注解解析的性能
        //关于Subscriber Index的更多信息可以参考官方文档 http://greenrobot.org/eventbus/documentation/subscriber-index/
        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            //如果类中没有找到Subscriber注解的方法，抛出异常
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            //将Subscriber注解的方法放入缓存并返回
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

从这个方法可以看出EventBus会将注册的订阅事件以Class对象为key，订阅方法的Method对象为value存入METHOD_CACHE缓存中，避免同一个类多次注册订阅时重复解析的问题，提升解析的性能。

在注解解析方面，EventBus提供了传统的反射解析与使用Subscriber Index两种方式，下面将主要对反射解析方式分别进行分析

SubscriberMethodFinder.findUsingReflection(Class

    private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
        //通过FindState对象池创建FindState对象
        FindState findState = prepareFindState();
        //初始化FindState对象
        findState.initForSubscriber(subscriberClass);

        while (findState.clazz != null) {
            //解析这个类中带有Subscribe注解的方法
            findUsingReflectionInSingleClass(findState);
            //向父类进行遍历
            findState.moveToSuperclass();
        }
        //获取解析出的方法，将findState重置并放回对象池中
        return getMethodsAndRelease(findState);
    }

    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            //getDeclaredMethods方法只会获取到该类所定义的方法，而getMethods方法会获取包括这个类的父类与接口中的所有方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            // 使用getMethods就已经获得了其父类的所有方法，所以将skipSuperClasses标志位设置为true，在后续过程中不对其父类进行解析
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //Subscribe注解的方法不应为私有且不应为抽象，静态等
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                //Subscribe注解的方法应有且只有一个参数
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class<?> eventType = parameterTypes[0];
                        //调用checkAdd方法判断是否将订阅事件添加进订阅列表中
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                }
            }
        }
    }

在这段代码中出现了一个FindState类对象，其中含有解析相关的配置，解析出的方法等等，整个解析的过程都是围绕着这个对象进行处理。

FindState.checkAdd

    final Map<Class, Object> anyMethodByEventType = new HashMap<>();
    final StringBuilder methodKeyBuilder = new StringBuilder(128);
    final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();

    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);
        // 第一级判断，如果existing为null，则代表该eventType为首次添加，直接返回true
        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
                // 该方法只为了将一个不是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
            // 撤销之前的put操作，并返回false
            subscriberClassByMethodKey.put(methodKey, methodClassOld);
            return false;
        }
    }

这部分代码的作用主要有两点：

当一个类重载了父类的一个订阅方法，在向上级父类遍历时跳过父类中的这个方法的订阅，也就是说以子类的订阅方法为准
允许一个类有多个方法名不同的方法对同个事件进行订阅

值得一提的是关于methodClassOld.isAssignableFrom(methodClass)这一句代码，有文章提到因为之前的代码中会使用Class.getMethods()方法，会得到这个类以及父类的public方法，所以这句代码的结果可能为true，但是经我测试，如果父类方法被子类重载，那么getMethods方法得到的只会有子类的重载方法一个，父类的方法并不会出现，所以从这方面来说，这句代码依然只能是false。

EventBus.register(Object subscriber, SubscriberMethod subscriberMethod)

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

        //将参数类型以订阅者对象为key，参数类型列表为value保存进一个Map中
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //对于一般的事件的注册，到这里就已经完成了
        //-----------------------------------------------------------------------------

        //针对粘性事件订阅者的处理
        if (subscriberMethod.sticky) {
            //eventInheritance：是否支持事件继承，默认为true。当为true时，post一个事件A时，若A是B的父类，订阅B的订阅者也能接收到事件。
            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);
            }
        }
    }

到现在为止，其实已经可以总结出EventBus中订阅者注册的核心逻辑了，就是筛选出注册的类中带有Subscribe注解的方法，然后将其解析为SubscriberMethod对象，以订阅的事件类型为key，SubscriberMethod对象为value的形式存入subscribedEvents中。

对于粘性事件的发送，其实与之后的一般事件执行逻辑相同，这里就不再深入了。

EventBus.getDefault().post(new MessageEvent(“Hello everyone!”))

EventBus.post(Object event)

    public void post(Object event) {
        //从ThreadLocal中取出PostingThreadState对象，PostingThreadState对象只是保存一些消息发送过程中需要的信息
        //使用ThreadLocal保证PostingThreadState对象在各线程间相互独立，以此实现线程安全
        PostingThreadState postingState = currentPostingThreadState.get();
        //从PostingThreadState对象中取出当前线程的消息队列，并将需要发送的消息加入队列中
        List<Object> eventQueue = postingState.eventQueue;
        eventQueue.add(event);

        if (!postingState.isPosting) {
            postingState.isMainThread = isMainThread();
            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 {
                //遍历结束，重置PostingThreadState对象
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

在这段代码中，isMainThread()方法可以用来判断消息发送是否是在主线程中。其中的逻辑非常简单，通过Looper类中的getMainLooper()获取到主线程中的Looper对象，然后再通过Looper类中的myLooper()方法获取当前线程的Looper对象，然后相互比较。

EventBus.postSingleEvent(Object event, PostingThreadState postingState)

    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        //如果该消息支持事件继承，则获取该消息类型的所有父类与接口类型，并分别调用postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass)方法
        if (eventInheritance) {
            //获取消息类型的所有父类与接口
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            //对于ArrayList而言，使用基本的for循环实现遍历效率更高
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }

        //如果该消息没有订阅者，则根据配置输出相应的log或发送消息
        if (!subscriptionFound) {
            if (logNoSubscriberMessages) {
                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

EventBus.postSingleEventForEventType(Object event, PostingThreadState postingState, Class

    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            //从Map中将该消息的订阅事件列表取出
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        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;
    }

这个方法的主要作用就是获得消息的订阅事件列表，完成对于postingState中参数的赋值，其中对于所有的订阅事件，使用的其实是同一个PostingThreadState对象，只是对于不同的订阅事件，会改变其中的部分参数的值。

EventBus.postToSubscription(Subscription subscription, Object event, boolean isMainThread)

    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED:
                if (mainThreadPoster != null) {
                    mainThreadPoster.enqueue(subscription, event);
                } else {
                    // temporary: technically not correct as poster not decoupled from subscriber
                    invokeSubscriber(subscription, event);
                }
                break;
            case BACKGROUND:
                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);
        }
    }

在默认情况下，EventBus会在调用线程中直接执行invokeSubscriber方法调用订阅事件，但当调用线程与期望的执行线程不一致或希望异步调用时，使用Poster来进行不同线程间的调度，每一个Poster中都会持有一个消息队列，并在指定线程执行。

EventBus.invokeSubscriber(Subscription subscription, Object event)

    void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            //如果捕获到InvocationTargetException异常，则根据配置打印Log或发送异常消息
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

这段代码也就是订阅事件执行部分的最后一段代码了，可以看到逻辑非常的简单，就是通过反射来执行相应的订阅事件。