EventBus源码详解

作者: wang_zd | 来源:发表于2019-01-16 13:41 被阅读12次

1.简介

EventBus 是一个在 Android和Java上使用的事件发布/订阅框架，通过解耦发布者和订阅者简化 Android 事件传递，事件传递既可用于 Android 四大组件间通讯，也可以用户异步线程和主线程间通讯等等。
相比传统Handle,Interface回调，BroadCastReceiver等。EventBus的优点是代码简介，使用简单，并将事件发布和订阅充分解耦。

2.简单使用

@Override
protected void onStart() { //订阅
    super.onStart();
    EventBus.getDefault().register(this);
}

@Override
protected void onStop() { //取消订阅
    super.onStop();
    EventBus.getDefault().unregister(this);
}


@Subscribe(threadMode = ThreadMode.MAIN, sticky = false, priority = 1)
public void onMessageEvent(MsgEvent event) { //响应方法
    Toast.makeText(this, event.message, Toast.LENGTH_SHORT).show();
}

3.类详解

EventBus的创建（单例 + Builder ）

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

单例+Build方式很常见，EventBus构造方法一般在单例中为private，在这使用public的意义在于让用户可自己构建EventBus 新建的EventBus和默认的实例发布和订阅事件都是相互隔离的，互不干扰。新建一个EventBus:

EventBus mEventBus = EventBus.builder().addIndex(new MyEventBusIndex()).build();

3.1订阅逻辑

先找订阅者A下所有订阅方法。
以A订阅的事件类型为分别key，A+A的订阅方法（key类型）为value放进subscriptionsByEventType Map中
以A类名为key,A中的订阅方法参数类型为value放入typesBySubscriber Map中
如果是订阅了粘滞事件的订阅者，从粘滞事件缓存区获取之前发送过的粘滞事件，响应这些粘滞事件。
来自CodeKK分析EventBus订阅流程图
订阅流程.png

    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);
            }
        }
    }
    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //发送事件类型，比如是String
        Class<?> eventType = subscriberMethod.eventType;
       //把订阅者和方法组合成一个对象Subscription 。
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
       //把订阅了指定类型（如String）的Subscriptions 放进subscriptionsByEventType中
       //如订阅了String类型的有什么类，这些类中有什么方法。
       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;
            }
        }
        //typesBySubscriber包含了一个类订阅了那些类型事件
        //如TestActivity有两个响应方法，一个事件是String，一个是int
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //是sticky方法则取出对应的sticky事件post给当前方法
        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);
            }
        }
    }

3.2发送&响应事件

从ThreadLocal中取出当前事件分发封装对象PostingThreadState，从该对象中取出发送事件的事件队列，把要post的事件加入此队列。
如果PostingThreadState不是正在发送事件，则不断从队列中取出事件。分发给订阅了此事件的方法。
3.根据每个响应方法的ThreadMode不同，采用不同的Poster响应事件。

来自CodeKK分析EventBus Post流程图

Post流程.png

3.2.1ThreadMode 的5种类型。

POSTING： 默认的ThreadMode 类型，表示在post线程直接执行响应订阅方法，不管是主线程还是子线程。所以在主线程时不能有时不能有耗时操作。
MAIN：在主线程响应订阅方法，如果post在主线程则直接响应，如果不是则加入队列用Handler处理消息，适合必须在主线程处理事件，所以不能做耗时操作
MAIN_ORDERED：和MAIN类似，但是不会根据post是否在主线程做出响应，而是直接加入队列用Handler处理，确保Post调用不会阻塞。
BACKGROUND：如果post不在主线程，则直接响应方法，在主线程则加入队列使用BackgroundPoster处理消息。这里是启动唯一的后台线程处理响应方法，事件多了就会阻塞等待前面事件完成。所以使用场景为：操作轻微耗时且不会过于频繁，即一般的耗时操作都可以放在这里
ASYNC：不论post在哪个线程，直接使用线程池中的空闲线程处理。和BACKGROUND不同，这里不会阻塞。适合耗时操作

3.2.2分析下BackgroundPoster的"唯一"线程

enqueue时会用synchronized 锁住当前BackgroundPoster 对象，必须前面的事件处理完了才能继续处理下个事件。虽然是用的线程池处理事件。但是在某一时刻只有唯一的一个线程在处理事件。

final class BackgroundPoster implements Runnable, Poster {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) { //等待。
            queue.enqueue(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                eventBus.getExecutorService().execute(this); //处理事件
            }
        }
    }

    @Override
    public void run() {
        try {
            try {
                while (true) {
                    //最多等1s
                    PendingPost pendingPost = queue.poll(1000); 
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

AsyncPoster 则是并行执行的，每个事件直接入队用空闲线程处理。

class AsyncPoster implements Runnable, Poster {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    AsyncPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        queue.enqueue(pendingPost);
        eventBus.getExecutorService().execute(this);
    }

    @Override
    public void run() {
        PendingPost pendingPost = queue.poll();
        if(pendingPost == null) {
            throw new IllegalStateException("No pending post available");
        }
        eventBus.invokeSubscriber(pendingPost);
    }

}

3.2.3看下发送Sticky事件

也是调用post，但之前先把事件添加进缓存。对应在register时，保存订阅方法时，如果该方法时sticky的。则要从stickyEvents取出事件执行该方法。所以这刚注册的方法也能执行之前发送的消息，完成粘性功能。

    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

4.主要成员变量含义

查看地址

变量含义.png

5.使用EventBus可优化点

开启索引，可以在寻找订阅方法时不适用反射，提升效率
开启索引

EventBus mEventBus = EventBus.builder().addIndex(new MyEventBusIndex()).build();

//寻找订阅者里的方法。
 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) { //默认false
           //反射
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
           //从MyEventBusIndex找，找不到用反射
            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;
        }
    }

eventInheritance是否使用事件继承，默认为true。
例如：B继承与A，发送事件B会也发送A。
可以关闭设置为false。提升性能。

EventBus源码详解

1.简介

2.简单使用

3.类详解

3.1订阅逻辑

3.2发送&响应事件

3.2.1ThreadMode 的5种类型。

3.2.2分析下BackgroundPoster的"唯一"线程

3.2.3看下发送Sticky事件

4.主要成员变量含义

5.使用EventBus可优化点

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读