撸EventBus源码

源码是eventbus-3.1.1

代码入口：

  • EventBus.getDefault().register(Object subscriber)注册订阅者
  • EventBus.getDefault().unregister(Object subscriber)注销订阅者
  • EventBus.getDefault().post(Object event)发送事件
  • @Subscribe()订阅者

创建EventBus

EventBus.getDefault().register(Object subscriber)可以看到EventBus的使用是单例模式：

static volatile EventBus defaultInstance;

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

DCL的单例模式为什么静态变量instance要使用volatile标签？

查看new EventBus()：

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

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

这里在new EventBus的时候又使用了构造者模式。
EventBus中几个主要的成员变量：

  • Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType
    这个subscriptionsByEventType的key是事件类，value是订阅者list，其中list使用的线程安全的CopyOnWriteArrayList。
  • Map<Object, List<Class<?>>> typesBySubscriber
    这个typesBySubscriber的key为订阅者，value为订阅者的事件list
  • Map<Class<?>, Object> stickyEvents
    这个stickyEvents为粘性事件，key为事件的类，value为事件对象

注册

public void register(Object subscriber) {
    //获取订阅者类名
    Class<?> subscriberClass = subscriber.getClass();
    // 1   获取订阅者订阅的方法   
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
    // 2  在同步块中将订阅方法进行注册
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

一般情况下register的入参是Activity、Service、Fragment这个有生命周期的对象，所有在对象的生命周期开始的地方进行注册，并在生命周期结束的时候进行注销。

看标注1处，这里使用subscriberMethodFinder的findSubscriberMethods()方法获取订阅者的订阅方法：

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    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;
    }
}

可以看到方法中先查看缓存中是否存在此订阅者的订阅方法，如果没有就通过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 {
            findUsingReflectionInSingleClass(findState);
        }
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

这里通过findUsingReflectionInSingleClass(findState);方法进行查找订阅方法，查找完成后会继续查找订阅者类的父类的订阅方法，直到当前查找的类是系统类时跳出循环。

    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();
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                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()));
                        }
                    }
                } 
                ...
        }
    }

从名字就可以看出是通过反射的方法进行查找，在查找的过程中通过遍历每个订阅者类的每个方法的注解，如有存在@Subscribe()则表明是订阅方法，并将这个method的注解参数进行解析，最终一并加入list中。

至此，注册的第一步完成：获取订阅者类的订阅方法（因为方法可能多个，所有用list）。再看注册的第二部分：

        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }

主要看subscribe(subscriber, subscriberMethod)方法。

    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取这个订阅方法中订阅的事件（订阅方法的入参）
        Class<?> eventType = subscriberMethod.eventType;
        //通过订阅类和订阅方法注册一个订阅对象Subscription
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        /**
         * 获取订阅当前事件的所有订阅对象，
         * 如果为空那就创建一个list用于存储，并将这个list放入subscriptionsByEventType中
         **/
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, 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;
            }
        }
        //将当前订阅类作为key，订阅事件作为value传入typesBySubscriber中
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        //POST粘性事件
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
            //  包含事件父类的情况（默认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<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对象中，为后面事件的发送进行处理；粘性事件会在订阅的类注册完成的时候触发订阅方法。

注销

    public synchronized void unregister(Object subscriber) {
        // 1 根据订阅类获取订阅事件
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class<?> eventType : subscribedTypes) {
                // 2 解除订阅事件和订阅类的绑定关系
                unsubscribeByEventType(subscriber, eventType);
            }
            // 3 移除订阅类
            typesBySubscriber.remove(subscriber);
        } 
        ...
    }

注销方法中第一个注释的地方是通过订阅类获取订阅事件，然后对每一个订阅事件解除与订阅类的关系，最后移除订阅类。

解除订阅事件和订阅类的绑定关系使用的是unsubscribeByEventType(subscriber, eventType);方法：

private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions != null) {
            int size = subscriptions.size();
            for (int i = 0; i < size; i++) {
                Subscription subscription = subscriptions.get(i);
                if (subscription.subscriber == subscriber) {
                    subscription.active = false;
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

从subscriptionsByEventType中获取所有订阅事件对应的订阅者（Subscription），遍历订阅者list，找出所有订阅类的Subscription，并从中移除。

注意代码中list的选择删除，每删除一个元素，都有i--;size--;不然就会报索引越界的异常。

发送订阅事件 post(Object event)


    private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

    final static class PostingThreadState {
        final List<Object> eventQueue = new ArrayList<>();
        boolean isPosting;
        boolean isMainThread;
        Subscription subscription;
        Object event;
        boolean canceled;
    }

    public void post(Object event) {
        // 1
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        eventQueue.add(event);

        if (!postingState.isPosting) {
            // 2
            postingState.isMainThread = isMainThread();
            postingState.isPosting = true;
            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                while (!eventQueue.isEmpty()) {
                    // 3
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

订阅事件发送主要分三步：

  1. 从currentPostingThreadState中获取当前线程的信息：
  • 当前线程的待发送事件对列
  • 发送状态
    currentPostingThreadState是一个threadLocal对象，为每一个线程存储订阅事件的信息。
  1. 判断当前线程是不是主线程，后面可以看到主线程和子线程发送事件的方式不同
  2. 从头开始逐一将当前线程的订阅事件发送出去，使用postSingleEvent(eventQueue.remove(0), postingState);方法。
    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        if (eventInheritance) {
            // 1
            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 {
            // 2
            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));
            }
        }
    }

注释1处是对于订阅事件的超类和接口一并进行发送，注释2处只发送订阅事件，所以主要关注postSingleEventForEventType(event, postingState, eventClass)方法。

    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            // 1
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    // 2
                    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;
    }

注释1处获取当前订阅事件对应的所有订阅对象；在注释2处逐条进行发送，使用postToSubscription(subscription, event, postingState.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);
        }
    }

可以看出，这里针对订阅方法的注解的不同，发送到不同的线程：

  • POSTING：通过发射直接调用订阅方法，没有线程切换，性能损耗最小
  • MAIN：如果发送事件的线程就是主线程，那就反射调用订阅方法；如果不是，那就将订阅事件加入主线程的发送队列
  • MAIN_ORDER：对于Android，不论在哪个线程发送，都将订阅事件加入主线程的发送队列
  • BACKGROUND：如果发送事件的线程是主线程，那就将事件加入子线程的发送队列；否则直接反射调用订阅方法
  • ASYNC：将事件加入异步发送队列
    反射调用订阅方法比较简单，直接调用invokeSubscriber(subscription, event);方法即可。
    这里主要看看三个发送队列的实现：
  • HandlerPoster mainThreadPoster
  • BackgroundPoster backgroundPoster
  • AsyncPoster asyncPoster
    发送队列都实现了Poster接口的void enqueue(Subscription subscription, Object event);方法。

HandlerPoster mainThreadPoster

mainThreadPoster的创建为：new HandlerPoster(eventBus, looper, 10);。
实现的enqueue()方法和handleMessage()方法如下：

    @Override
    public void enqueue(Subscription subscription, Object event) {
        // 1
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            // 2
            queue.enqueue(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                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) {
                // 3
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }
                // 4
                eventBus.invokeSubscriber(pendingPost);
                long timeInMethod = SystemClock.uptimeMillis() - started;
                if (timeInMethod >= maxMillisInsideHandleMessage) {
                    if (!sendMessage(obtainMessage())) {
                        throw new EventBusException("Could not send handler message");
                    }
                    rescheduled = true;
                    return;
                }
            }
        } finally {
            handlerActive = rescheduled;
        }
    }

注释1处创建出一个PendingPost对象，PendingPost对象中包含了订阅事件和订阅对象，为了节省资源避免频繁GC，使用池化的方式重复利用一组PendingPost对象。
注释2处，将PendingPost对象加入mainThreadPoster的队列中，然后发送一个消息（这里的消息不区分内部的内容，只要发送出去就会在handleMessage处理）。
注释3处，获取到message，就从队列从依次弹出PendingPost对象。
注释4处使用反射的方法执行订阅方法，此时执行的方法已经在主线程中执行。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,802评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,109评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,683评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,458评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,452评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,505评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,901评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,550评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,763评论 1赞 296
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,556评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,629评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,330评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,898评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,897评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,140评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,807评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,339评论 2赞 342

推荐阅读更多精彩内容

  • EventBus 3.0进阶：源码及其设计模式 完全解析
    前言 在上一篇文章：EventBus 3.0初探: 入门使用及其使用 完全解析中，笔者为大家介绍了EventBus...
    丶蓝天白云梦阅读 15,797评论 21赞 128
  • EventBus分析
    EventBus基本使用 EventBus基于观察者模式的Android事件分发总线。 从这个图可以看出，Even...
    顾氏名清明阅读 616评论 0赞 1
  • eventbus
    先吐槽一下博客园的MarkDown编辑器，推出的时候还很高兴博客园支持MarkDown了，试用了下发现支持不完善就...
    Ten_Minutes阅读 557评论 0赞 2
  • EventBus原理解析
    EventBus是一个Android开源库，其使用发布/订阅模式，以提供代码间的松耦合。EventBus使用中央通...
    壮少Bryant阅读 653评论 0赞 4
  • 往哪里走
    2018年12月26号又折腾了一轮，元旦是好了，生活还是混沌的样子？ 不想行尸走肉般地活着，怎么活成了愁心事。计划...
    春雨_373c阅读 82评论 0赞 1