Android架构师之路-EventBus3.0事件总线框架原理详解(一文彻底搞懂)

前沿小记

1、关于架构师学习的知识点很多,学到手才是自己的;

2、之前发过文章有自定义注解、设计模式、反射、多线程、组件化等;

3、实际开发中EventBus事件总线用到的很多,今天我们就解析下原理和用到的知识点;

4、在eventbus源码中可以学习到很多的知识点如下:

单例模式,而且是双重校验的单例,确保在不同线程中也只存在一个EvenBus的实例;

观察者模式:定义了对象之间的一对多依赖,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新;

自定义注解等等。

一、EventBus介绍

1、什么是EventBus

  • 由greenrobot 组织贡献(该组织还贡献了greenDAO),一个Android事件发布/订阅轻量级框架,通过解耦发布者和订阅者简化Android事件传递;
  • EventBus可以代替Android传统的Intent,Handler,Broadcast或接口函数,在Fragment,Activity,Service线程之间传递数据,执行方法;
  • EventBus 是一款在 Android 开发中使用的发布/订阅事件总线框架,基于观察者模式,将事件的接收者和发送者分开,简化了组件之间的通信,使用简单、效率高、体积小 ;

2、eventbus功能和优势

  • 通过解耦发布者和订阅者简化Android事件传递;
  • 用于线程间的通讯代替handler或用于组件间的通讯代替Intent;
  • 简化了组件间的通讯;
  • 分离了事件的发送者和接受者;
  • 在Activity、Fragment和线程中表现良好;
  • 避免了复杂的和易错的依赖关系和生命周期问题;
  • 使得代码更简洁,性能更好;

二、EventBus原理

图片

EventBus 背后的实现原理主要包括如下几个方面的内容:

  • Subscribe注解
  • 注册事件订阅方法
  • 取消注册
  • 发送事件
  • 事件处理

1、Subscribe注解

EventBus3.0 开始用Subscribe注解配置事件订阅方法

@Subscribepublic void handleEvent(String event) {    // do something}

具体看下Subscribe注解的实现:

@Documented@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.METHOD})public @interface Subscribe {    // 指定事件订阅方法的线程模式,即在那个线程执行事件订阅方法处理事件,默认为POSTING    ThreadMode threadMode() default ThreadMode.POSTING;    // 是否支持粘性事件,默认为false    boolean sticky() default false;    // 指定事件订阅方法的优先级,默认为0,如果多个事件订阅方法可以接收相同事件的,则优先级高的先接收到事件    int priority() default 0;}

在使用Subscribe注解时可以根据需求指定threadMode、sticky、priority三个属性;

其中threadMode属性有如下几个可选值:

  • ThreadMode.POSTING,默认的线程模式,在那个线程发送事件就在对应线程处理事件,避免了线程切换,效率高;
  • ThreadMode.MAIN,如在主线程(UI线程)发送事件,则直接在主线程处理事件;如果在子线程发送事件,则先将事件入队列,然后通过 Handler 切换到主线程,依次处理事件;
  • ThreadMode.MAIN_ORDERED,无论在那个线程发送事件,都先将事件入队列,然后通过 Handler 切换到主线程,依次处理事件;
  • ThreadMode.BACKGROUND,如果在主线程发送事件,则先将事件入队列,然后通过线程池依次处理事件;如果在子线程发送事件,则直接在发送事件的线程处理事件;
  • ThreadMode.ASYNC,无论在那个线程发送事件,都将事件入队列,然后通过线程池处理;

2、注册事件订阅方法

图片

注册事件的方式如下:

EventBus.getDefault().register(this);

其中getDefault()是一个单例方法,保证当前只有一个EventBus实例:

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

在这里又调用了EventBus的构造函数来完成它相关属性的初始化:

public EventBus() {        this(DEFAULT_BUILDER);    }
EventBus(EventBusBuilder builder) {        logger = builder.getLogger();        subscriptionsByEventType = new HashMap<>();        typesBySubscriber = new HashMap<>();        stickyEvents = new ConcurrentHashMap<>();        mainThreadSupport = builder.getMainThreadSupport();        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;        backgroundPoster = new BackgroundPoster(this);        asyncPoster = new AsyncPoster(this);        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,                builder.strictMethodVerification, builder.ignoreGeneratedIndex);        logSubscriberExceptions = builder.logSubscriberExceptions;        logNoSubscriberMessages = builder.logNoSubscriberMessages;        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;        throwSubscriberException = builder.throwSubscriberException;        eventInheritance = builder.eventInheritance;        executorService = builder.executorService;    }

DEFAULT_BUILDER就是一个默认的EventBusBuilder:

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

有了EventBus的实例就可以进行注册了:

public void register(Object subscriber) {        // 得到当前要注册类的Class对象        Class<?> subscriberClass = subscriber.getClass();        // 根据Class查找当前类中订阅了事件的方法集合,即使用了Subscribe注解、有public修饰符、一个参数的方法        // SubscriberMethod类主要封装了符合条件方法的相关信息:        // Method对象、线程模式、事件类型、优先级、是否是粘性事等        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);        synchronized (this) {            // 循环遍历订阅了事件的方法集合,以完成注册            for (SubscriberMethod subscriberMethod : subscriberMethods) {                subscribe(subscriber, subscriberMethod);            }        }    }

可以看到register()方法主要分为查找和注册两部分,首先来看查找的过程,从findSubscriberMethods()开始:

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {        // METHOD_CACHE是一个ConcurrentHashMap,直接保存了subscriberClass和对应SubscriberMethod的集合,以提高注册效率,赋值重复查找。        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);        if (subscriberMethods != null) {            return subscriberMethods;        }        // 由于使用了默认的EventBusBuilder,则ignoreGeneratedIndex属性默认为false,即是否忽略注解生成器        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 {            // 保存查找到的订阅事件的方法            METHOD_CACHE.put(subscriberClass, subscriberMethods);            return subscriberMethods;        }    }

findSubscriberMethods()流程很清晰,即先从缓存中查找,如果找到则直接返回,否则去做下一步的查找过程,然后缓存查找到的集合,根据上边的注释可知findUsingInfo()方法会被调用:

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {        FindState findState = prepareFindState();        findState.initForSubscriber(subscriberClass);        // 初始状态下findState.clazz就是subscriberClass        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 {                // 通过反射查找订阅事件的方法                findUsingReflectionInSingleClass(findState);            }            // 修改findState.clazz为subscriberClass的父类Class,即需要遍历父类            findState.moveToSuperclass();        }        // 查找到的方法保存在了FindState实例的subscriberMethods集合中。        // 使用subscriberMethods构建一个新的List<SubscriberMethod>        // 释放掉findState        return getMethodsAndRelease(findState);    }

findUsingInfo()方法会在当前要注册的类以及其父类中查找订阅事件的方法,这里出现了一个FindState类,它是SubscriberMethodFinder的内部类,用来辅助查找订阅事件的方法,具体的查找过程在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类型,但非abstract、static等            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {                // 获得当前方法所有参数的类型                Class<?>[] parameterTypes = method.getParameterTypes();                // 如果当前方法只有一个参数                if (parameterTypes.length == 1) {                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);                    // 如果当前方法使用了Subscribe注解                    if (subscribeAnnotation != null) {                        // 得到该参数的类型                        Class<?> eventType = parameterTypes[0];                        // checkAdd()方法用来判断FindState的anyMethodByEventType map是否已经添加过以当前eventType为key的键值对,没添加过则返回true                        if (findState.checkAdd(method, eventType)) {                             // 得到Subscribe注解的threadMode属性值,即线程模式                            ThreadMode threadMode = subscribeAnnotation.threadMode();                            // 创建一个SubscriberMethod对象,并添加到subscriberMethods集合                            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()方法中findSubscriberMethods()流程就分析完了,我们已经找到了当前注册类及其父类中订阅事件的方法的集合。接下来分析具体的注册流程,即register()中的subscribe()方法:

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {        // 得到当前订阅了事件的方法的参数类型        Class<?> eventType = subscriberMethod.eventType;        // Subscription类保存了要注册的类对象以及当前的subscriberMethod        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);        // subscriptionsByEventType是一个HashMap,保存了以eventType为key,Subscription对象集合为value的键值对        // 先查找subscriptionsByEventType是否存在以当前eventType为key的值        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);        // 如果不存在,则创建一个subscriptions,并保存到subscriptionsByEventType        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);            }        }        // 添加上边创建的newSubscription对象到subscriptions中        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;            }        }        // typesBySubscribere也是一个HashMap,保存了以当前要注册类的对象为key,注册类中订阅事件的方法的参数类型的集合为value的键值对        // 查找是否存在对应的参数类型集合        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);        // 不存在则创建一个subscribedEvents,并保存到typesBySubscriber        if (subscribedEvents == null) {            subscribedEvents = new ArrayList<>();            typesBySubscriber.put(subscriber, subscribedEvents);        }        // 保存当前订阅了事件的方法的参数类型        subscribedEvents.add(eventType);        // 粘性事件相关的,后边具体分析        if (subscriberMethod.sticky) {            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);            }        }    }

这就是注册的核心流程,所以subscribe()方法主要是得到了subscriptionsByEventType、typesBySubscriber两个 HashMap。我们在发送事件的时候要用到subscriptionsByEventType,完成事件的处理。当取消 EventBus 注册的时候要用到typesBySubscriber、subscriptionsByEventType,完成相关资源的释放;

3、取消注册

图片

EventBus 取消注册:

EventBus.getDefault().unregister(this);

核心的方法就是unregister():

public synchronized void unregister(Object subscriber) {        // 得到当前注册类对象 对应的 订阅事件方法的参数类型 的集合        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);        if (subscribedTypes != null) {            // 遍历参数类型集合,释放之前缓存的当前类中的Subscription            for (Class<?> eventType : subscribedTypes) {                unsubscribeByEventType(subscriber, eventType);            }            // 删除以subscriber为key的键值对            typesBySubscriber.remove(subscriber);        } else {            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());        }    }继续看unsubscribeByEventType()方法:private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {        // 得到当前参数类型对应的Subscription集合        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);        if (subscriptions != null) {            int size = subscriptions.size();            // 遍历Subscription集合            for (int i = 0; i < size; i++) {                Subscription subscription = subscriptions.get(i);                // 如果当前subscription对象对应的注册类对象 和 要取消注册的注册类对象相同,则删除当前subscription对象                if (subscription.subscriber == subscriber) {                    subscription.active = false;                    subscriptions.remove(i);                    i--;                    size--;                }            }        }    }

所以在unregister()方法中,释放了typesBySubscriber、subscriptionsByEventType中缓存的资源;

4、事件通知

图片

发送一个事件的时候,我们可以通过如下方式

EventBus.getDefault().post("Hello World!"

通过post()方法完成的:

所以post()方法先将发送的事件保存的事件队列,然后通过循环出队列,将事件交给postSingleEvent()方法处理





postSingleEvent()方法中,根据eventInheritance属性,决定是否向上遍历事件的父类型,然后用postSingleEventForEventType()方法进一步处理事件

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {        CopyOnWriteArrayList<Subscription> subscriptions;        synchronized (this) {            // 获取事件类型对应的Subscription集合            subscriptions = subscriptionsByEventType.get(eventClass);        }        // 如果已订阅了对应类型的事件        if (subscriptions != null && !subscriptions.isEmpty()) {            for (Subscription subscription : subscriptions) {                // 记录事件                postingState.event = event;                // 记录对应的subscription                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;    }

postSingleEventForEventType()方法核心就是遍历发送的事件类型对应的Subscription集合,然后调用postToSubscription()方法处理事件

5、事件处理

postToSubscription()内部会根据订阅事件方法的线程模式,间接或直接的以发送的事件为参数,通过反射执行订阅事件的方法

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 {                     // 如果是在子线程发送事件,则将事件入队列,通过Handler切换到主线程执行处理事件                    // mainThreadPoster 不为空                    mainThreadPoster.enqueue(subscription, event);                }                break;            // 无论在那个线程发送事件,都先将事件入队列,然后通过 Handler 切换到主线程,依次处理事件。            // mainThreadPoster 不为空            case MAIN_ORDERED:                if (mainThreadPoster != null) {                    mainThreadPoster.enqueue(subscription, event);                } else {                    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);        }    }

可以看到,postToSubscription()方法就是根据订阅事件方法的线程模式、以及发送事件的线程来判断如何处理事件,至于处理方式主要有两种:

一种是在相应线程直接通过invokeSubscriber()方法,用反射来执行订阅事件的方法,这样发送出去的事件就被订阅者接收并做相应处理了,

void invokeSubscriber(Subscription subscription, Object event) {        try {            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);        } catch (InvocationTargetException e) {            handleSubscriberException(subscription, event, e.getCause());        } catch (IllegalAccessException e) {            throw new IllegalStateException("Unexpected exception", e);        }    }

另外一种是先将事件入队列(其实底层是一个List),然后做进一步处理,我们以mainThreadPoster.enqueue(subscription, event)为例简单的分析下,其中mainThreadPoster是HandlerPoster类的一个实例,来看该类的主要实现,

public class HandlerPoster extends Handler implements Poster {    private final PendingPostQueue queue;    private boolean handlerActive;    ......    public void enqueue(Subscription subscription, Object event) {        // 用subscription和event封装一个PendingPost对象        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);        synchronized (this) {            // 入队列            queue.enqueue(pendingPost);            if (!handlerActive) {                handlerActive = true;                // 发送开始处理事件的消息,handleMessage()方法将被执行,完成从子线程到主线程的切换                if (!sendMessage(obtainMessage())) {                    throw new EventBusException("Could not send handler message");                }            }        }    }    @Override    public void handleMessage(Message msg) {        boolean rescheduled = false;        try {            long started = SystemClock.uptimeMillis();            // 死循环遍历队列            while (true) {                // 出队列                PendingPost pendingPost = queue.poll();                ......                // 进一步处理pendingPost                eventBus.invokeSubscriber(pendingPost);                ......            }        } finally {            handlerActive = rescheduled;        }    }}

所以HandlerPoster的enqueue()方法主要就是将subscription、event对象封装成一个PendingPost对象,然后保存到队列里,之后通过Handler切换到主线程,在handleMessage()方法将中将PendingPost对象循环出队列,交给invokeSubscriber()方法进一步处理:

void invokeSubscriber(PendingPost pendingPost) {        Object event = pendingPost.event;        Subscription subscription = pendingPost.subscription;        // 释放pendingPost引用的资源        PendingPost.releasePendingPost(pendingPost);        if (subscription.active) {            // 用反射来执行订阅事件的方法            invokeSubscriber(subscription, event);        }    }

这个方法很简单,主要就是从pendingPost中取出之前保存的event、subscription,然后用反射来执行订阅事件的方法,又回到了第一种处理方式。所以mainThreadPoster.enqueue(subscription, event)的核心就是先将将事件入队列,然后通过Handler从子线程切换到主线程中去处理事件;

backgroundPoster.enqueue()和asyncPoster.enqueue也类似,内部都是先将事件入队列,然后再出队列,但是会通过线程池去进一步处理事件。

总结:

  • EventBus底层采用的是注解和反射的方式来获取订阅方法信息;
  • 整个EventBus可以看出,事件是被观察者,订阅者类是观察者,当事件出现或者发送变更的时候,会通过EventBus通知观察者,使得观察者的订阅方法能够被自动调用;
阅读原文

简介:一个有10多年经验开发的android、java、前端等语言的老程序员,在这里一起聊聊技术,一起聊聊生活、一起聊聊中年危机的生存之道,一起进步一起加油,感兴趣的欢迎订阅;不定时的更新。欢迎关注微信公众号:Android开发编程
(0)
打赏 喜欢就点个赞支持下吧 喜欢就点个赞支持下吧

声明:本文来自“Android开发编程”,分享链接:https://www.zyxiao.com/p/297306    侵权投诉

网站客服
网站客服
内容投稿 侵权处理
分享本页
返回顶部