手撕EventBus

作者: ClericYi | 来源:发表于2020-02-22 11:16 被阅读0次

思维导图

使用方法

在app下的build.gradle的dependencies中进行引入,当然高版本也容易出现问题。

implementation 'org.greenrobot:eventbus:3.2.0'

使用三步骤：
（1）定义事件

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

（2）定义注册和注销

// 当对应的消息发送到时会被调用的方法 
// 根据对应的实体类来对应处理的方式
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}

@Subscribe
public void handleSomethingElse(SomeOtherEvent event) {
    doSomethingWith(event);
}
// 生命周期start中注册
@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}
// 生命周期stop中注销
@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

（3）发送消息

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

源码导读

每次在看源码之前，我们都需要干的事情是知道这个东西要干什么。
EventBus作为消息的发布/订阅总线框架，最终基于的还是一个观察者模式。而方法将是我们对源码的整个切入点，所以我们要知道他能干什么，才知道怎么去读源码。
（1）Subscribe注解的使用
（2）注册和注销
（3）发送和处理事件
（4）粘性事件

Subscribe注解的使用

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    // 线程的模式，默认为POSTING
    ThreadMode threadMode() default ThreadMode.POSTING;
    // 是否坚持粘性事件，默认不支持
    boolean sticky() default false;
    // 一个优先级标识，默认为0
    int priority() default 0;
}

关于上述中的线程的模式也是大有文章。

public enum ThreadMode {
    // 在当前的线程中直接处理。
    POSTING,
    // 在主线程中发送事件，则直接处理，但是要求处理量小；在子线程中，就通过Handler发送后，再由主线程处理
    MAIN,
    // 总是入队列进行等待，通过Handler发送事件后，再由主线程处理
    MAIN_ORDERED,
    // 在主线程中发送事件，入队列依次处理；在子线程中发送事件，则直接处理。
    BACKGROUND,
    // 总是入队列等待，通过线程池异步处理。
    ASYNC
}

注册和注销

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

注销

一般来说麻烦的都是注册的过程，所以我们反其道而行之，我们先看注销。

public synchronized void unregister(Object subscriber) {
        // 获得context对应的订阅事件的参数类型集合
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            // 循环遍历，删去对应的数据
            for (Class<?> eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            // 本质就是一个map，而context就是一个key，删去key罢了。
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

注册

上面讲过了注销，当前就是重头戏的注册了。
在整个的代码中，其实我还没有介绍getDefault()这个方法，所以先看看这个方法。

static volatile EventBus defaultInstance;

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

DCL不清楚的读者可以看看聊一聊设计模式（二）-- 创建型设计模式

很轻松，就是一个DCL的方式来创建一个单例，那么这个时候我们也就拥有了EventBus的一个实例了，自然就能注册了。

public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        // 其实就是寻找到带有@Subscribe注解的方法集合
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            // 同步方式完成订阅事件的绑定
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

从上述的代码中，我们知道他的大致流程其实就是分为两步，查询和注册。

查询

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        // 先是从缓存中取，有则直接返回，无则寻找
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        // 因为我们一般使用的都是getDefault()来进行一个注册，所以ignoreGeneratedIndex默认为false。去查看EventBusBuilder即可，会看到未赋值，也就是默认值的false
        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 默认调用的方法
            subscriberMethods = findUsingInfo(subscriberClass); // 1
        }
        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;
        }
    }

这个工作流程是非常清晰的，我们的下一步就是要进入findUsingInfo()这个函数。

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(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 {
                // 一般进入这个方法，通过反射的方式判断方法使用是否满足一些基本条件
                // 是否是public修饰，是否为一个参数，是否为静态，是否为抽象类
                findUsingReflectionInSingleClass(findState);
            }
            // 对subscriberClass的父类再进行查询
            findState.moveToSuperclass();
        }
        // 对遍历获得的方法进行重构
        // 对findState进行回收
        return getMethodsAndRelease(findState);
    }

到此为止我们就能够获得我们打过注解的方法们了。

注册

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        // 如果subscriptionsByEventType中并不存在对应的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;
            }
        }
        // 以context作为key，来存储订阅事件
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        // 对粘性事件的一个具体操作
        if (subscriberMethod.sticky) {
           // 。。。。。。
        }
    }

这么一大串看下来，想来很多人很跳过，毕竟代码真的太多了。其实还是一样抽主干，它针对的变量只有两个typesBySubscriber、subscriptionsByEventType。为什么这么说的？就是一个反推的思想，注册中要保存的东西，在注销的时候是一定要删除的，那我们去看看注销就知道了。

发送和处理事件

发送事件

EventBus.getDefault().post(new MessageEvent("MessageEvent"));

这里唯一的需要了解的就是post()这个函数。

public void post(Object event) { 
        // 一个PostingThreadState 类型的ThreadLocal
        // PostingThreadState是存储了事件队列，线程模式等等信息的类
        PostingThreadState postingState = currentPostingThreadState.get();
        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 {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

我们已经知道了，最开始是一系列的判定，到postSingleEvent()才开始正式办事儿。

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        // 判断是否向父类查询
        if (eventInheritance) {
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class<?> clazz = eventTypes.get(h);
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }
        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));
            }
        }
    }

上述的查询方法中出现了一个共同的特征，就是调用了postSingleEventForEventType()。

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

这个postToSubscription()方法，最后判定就是我们最开始说的threadMode，根据设置来给出相对应的处理方式。

处理事件

这里只讲解一种，因为其余的终究还是基于Handler来进行通信，所以只挑默认方法的POSTING讲解。

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            // 。。。。。
        }
}

这是发送部分的未讲解部分，其实已经和处理部分重合，所以就一起讲解。
我们说过POSTING方法是直接在当前的线程作出处理的。
查看源码也能够发现是不对isMainThread这个变量进行判定的。

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);
        }
    }

显然最后也就是调用了一个Method.invoke()方法来对我们的方法进行处理，这里也就直接对应了我们的相对应的定义的方法了。

粘性事件

EventBus.getDefault().postSticky(new MessageEvent("MessageEvent"));

通过postSticky()方法来进行一个调用

public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // 用锁机制存放后再发送，防止直接消费
        post(event);
    }

最后调用的还是一个post()方法，但是这里我们需要想起的是我们之前尚未分析的subscribe()中针对粘性事件做出处理的方法。（可以回到注册中进行查看）

if (subscriberMethod.sticky) {
            if (eventInheritance) {
                // 也就是对父类中的一种归并考虑
                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); // 1
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent); // 1
            }
        }
// 不论是if还是else最终都会调用到的注释1方法
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());
        }
    }

其实粘性事件的最终和发送事件殊途同归，都是需要调用postToSubscription()来将方法进行一个发送，只是，他多做了一个缓存的地方，也就是stickyEvents这个变量拿来对粘性事件进行一个存储操作。

总结

图片转载自SheHuan大佬的文章

register	post	unregister

以上就是我的学习成果，如果有什么我没有思考到的地方或是文章内存在错误，欢迎与我分享。

相关文章推荐：

手撕OkHttp

手撕AsyncTask

手撕ButterKnife

手撕Handler

手撕EventBus

思维导图

使用方法

源码导读

Subscribe注解的使用

注册和注销

注销

注册

查询

注册

发送和处理事件

发送事件

处理事件

粘性事件

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读