EventBus的使用及原理解析

EventBus 是一款在 Android 开发中使用的发布/订阅事件总线框架,基于观察者模式,将事件的接收者和发送者分离,避免复杂且容易出错的依赖关系和生命周期问题,简化了组件之间的通信,使用简单、效率高、体积小!下边是官方的 EventBus 原理图:
在这里插入图片描述

一、使用EventBus

EventBus支持订阅者方法在不同于发布事件所在线程的线程中被调用。你可以使用线程模式来指定调用订阅者方法的线程。这就需要了解EventBus支持的五种线程模式(ThreadMode):POSTING、MAIN、MAIN_ORDERED、BACKGROUND、ASYNC。

1.线程模式

  • POSTING
    POSTING是默认线程模式,在哪个线程发送事件就在对应线程处理事件,避免了线程切换,效率高。因此,对于不要求是主线程并且耗时很短的简单任务推荐使用该模式。在线程模型为POSTING的事件处理函数中尽量避免执行耗时操作,因为它会阻塞事件的传递,甚至有可能会引起ANR。
  • MAIN
    订阅者方法将在主线程(UI线程)中被调用。因此,可以在该模式的订阅者方法中直接更新UI界面。事件处理的时间不能太长,长了会导致ANR。
  • MAIN_ORDERED
    订阅者在主线程中调用。该事件总是排队等待以后交付给订阅者,因此对post的调用将立即返回。这为事件处理提供了更严格且更一致的顺序,例如,在具有MAIN线程模式的事件处理程序中发布另一个事件,则第二个事件处理程序将在第一个事件处理程序之前完成,事件处理的时间不能太长,长了会导致ANR。
  • BACKGROUND
    订阅者将在后台线程中调用。如果发布线程不是主线程,则将在发布线程中直接调用事件处理程序方法。如果发布线程是主线程,则EventBus使用单个后台线程,该线程将按顺序传递其所有事件。在此事件处理函数中禁止进行UI更新操作。
  • ASYNC
    无论事件在哪个线程中发布,该事件处理函数都会在新建的子线程中执行;同样,此事件处理函数中禁止进行UI更新操作。

2.基本使用

EventBus的使用分4步
(1)定义事件

public static class MessageEvent {... }

(2)准备订阅者(指定模式)

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {...};

(3)注册/注销订阅者(注册和注销是成对出现的)

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

(4)发送事件

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

3.使用示例

前面已经介绍了基本用法,下面看下使用示例:
首先配置gradle,如下所示:

implementation ‘org.greenrobot:eventbus:3.1.1’

(1)定义消息事件类

public class MessageEvent {
    private String message;

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

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

(2)订阅者处理事件

   @Subscribe(threadMode = ThreadMode.MAIN)
    public void onShowEventMessage(MessageEvent messageEvent){
        //将数据显示到页面上
        tvMessage.setText(messageEvent.getMessage());
    }

我们在MainActivity中创建一个订阅者处理事件onShowEventMessage方法,添加Subscribe注解,ThreadMode设置为MAIN,事件的处理会在UI线程中执行,用TextView来展示接收到的消息。

(3)注册和取消订阅事件

public class MainActivity extends AppCompatActivity {

    private Button btnJump;
    private Button btnReg;
    private TextView tvMessage;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnJump = findViewById(R.id.btn_jump);
        btnReg = findViewById(R.id.btn_reg);
        tvMessage = findViewById(R.id.tv_message);
        btnJump.setOnClickListener(v -> {
            //跳转到SecondActivity
            startActivity(new Intent(MainActivity.this,SecondActivity.class));
        });
        btnReg.setOnClickListener(v -> {
            //注册事件
            EventBus.getDefault().register(this);
        });
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //注销事件
        EventBus.getDefault().unregister(this);
    }
}

我们在MainAtivity中点击按钮注册事件,在onDestroy中注销事件。当我们注册事件后,跳转到SecondActivity中去发布事件。

(4)发布者发布事件

public class SecondActivity extends AppCompatActivity {

    private Button btnSend;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        btnSend = findViewById(R.id.btn_send);
        btnSend.setOnClickListener(v -> {
            //发送事件
            EventBus.getDefault().post(new MessageEvent("我要学习EventBus"));
            finish();
        });

    }
}

在SecondActivity中点击按钮发布事件后,返回到MainActivity中,可以看到页面上显示的就是我们发布的消息“我要学习EventBus”。在这里就不展示页面了。
EventBus的粘性事件
除了普通事件,EventBus还支持发送粘性事件,粘性事件就是在发送事件之后再订阅该事件也能收到该事件,这跟粘性广播类似。
(1)订阅者处理粘性事件

 @Subscribe(threadMode = ThreadMode.POSTING, sticky = true)
    public void onShowStickyEventMessage(MessageEvent messageEvent){
        //显示粘性事件
        tvMessage.setText(messageEvent.getMessage());
    }

在MainActivity中新写一个方法用来处理粘性事件,可以看到和普通事件基本类似,在注解中多加了一个sticky = true属性。我们先不注册事件,直接跳转到MainActivity中,回来后在点击注册事件,看看效果。
(2)发送粘性事件

 btnSend.setOnClickListener(v -> {
            //发送事件
            EventBus.getDefault().postSticky(new MessageEvent("我要学习EventBus的粘性事件"));
            finish();
        });

我们在SecondActivity中点击按钮发送粘性事件,我们可以看到普通事件是post()方法,而粘性事件是postSticky()方法,这点需要注意。再者,我们发送后,回到MainActivity中点击注册事件,我们就可以看到发送的事件了。

三、源码解析EventBus

下面我们看下EventBus的源码

1.注册订阅者

1.1EventBus构造方法
 EventBus.getDefault().register(this);

我们在使用EventBus时,首先会调用EventBus.getDefault()来获取实例,其中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);
    }

this调用了EventBus的另一个构造方法。而DEFAULT_BUILDER是默认的EventBusBuilder ,用来构造EventBus。

 private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

又创建EventBusBuilder对象,构造一个EventBusBuilder来对EventBus进行配置。

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

这里采用了建造者模式。当然我们也可以通过配置EventBusBuilder来更改EventBus的属性,如下方式也可以注册:

EventBus.builder()
        .eventInheritance(false)
        .logSubscriberExceptions(false)
        .build()
        .register(this);

下面我们看下register方法

    public void register(Object subscriber) {
        //获取类 通过debug可以看出获取出来的结果是com.monkey.eventbus.MainActivity
        Class<?> subscriberClass = subscriber.getClass();
        //找出传进来的订阅者的所有订阅方法
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        //进行同步操作
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

可以看到register()方法主要分为查找和注册两部分。

1.2查找订阅者的订阅方法

我们先看下SubscriberMethod都包含了什么:

public class SubscriberMethod {
    final Method method; //方法
    final ThreadMode threadMode;//执行线程
    final Class<?> eventType;//接收的事件类型
    final int priority;//优先级
    final boolean sticky;//是否粘性事件
    /** Used for efficient comparison */
    String methodString;

    public SubscriberMethod(Method method, Class<?> eventType, ThreadMode threadMode, int priority, boolean sticky) {
        this.method = method;
        this.threadMode = threadMode;
        this.eventType = eventType;
        this.priority = priority;
        this.sticky = sticky;
    }
      ...
}

我们可以看到SubscriberMethod 类中主要保存了订阅方法的Method对象,线程模式、事件类型、优先级、是否是粘性事件

下面来看查找的过程,findSubscriberMethods()方法:

 List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        //从缓存中查找是否有订阅方法,返回一个集合
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        //如果缓存中存在订阅方法,则直接返回
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //根据 ignoreGeneratedIndex属性值来选择采用何种方法查找订阅方法
        //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()流程很清晰,即先从缓存中查找,如果找到则直接返回,否则去做下一步的查找过程,然后缓存查找到的集合。我们在项目中经常通过EventBus单例模式来获取默认的EventBus对象,也就是ignoreGeneratedIndex为false的情况,这种情况会调用findUsingInfo()方法:

    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        //FindState其实就是一个里面保存了订阅者和订阅方法信息的一个实体类,包括订阅类中所有订阅的事件类型和所有的订阅方法等。
        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);
    }

findUsingInfo()方法会在当前要注册的类以及其父类中查找订阅事件的方法,最后再通过getMethodsAndRelease方法对findState做回收处理并返回订阅方法的List集合。具体的查找过程在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();
            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");
            }
        }
    }

查找的过程,就是对当前类中的方法进行遍历,找到符合条件的方法(即添加了Subscribe注解),获取相关属性值,添加到SubscriberMethod对象,将符合条件的对象添加到subscriberMethods集合中,即保存到findState中。

1.3订阅者的注册过程

在查找完订阅者的订阅方法后,就要对其进行注册。调用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);
        if (subscriptions == null) {
            // 如果不存在,则创建一个subscriptions,并保存到subscriptionsByEventType
            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) {
                // 添加上边创建的newSubscription对象到subscriptions中
                subscriptions.add(i, newSubscription);
                break;
            }
        }
        // typesBySubscriber也是一个HashMap,保存了以当前要注册类的对象为key,注册类中订阅事件的方法的参数类型的集合为value的键值对
        // 查找是否存在对应的参数类型集合
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            // 不存在则创建一个subscribedEvents,并保存到typesBySubscriber
            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>).
                // stickyEvents就是发送粘性事件时,保存了事件类型和对应事件
                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,完成相关资源的释放。
处理粘性事件就是在 EventBus 注册时,遍历stickyEvents,如果当前要注册的事件订阅方法是粘性的,并且该方法接收的事件类型和stickyEvents中某个事件类型相同或者是其父类,则取出stickyEvents中对应事件类型的具体事件,通过checkPostStickyEventToSubscription()方法做进一步处理。

    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()方法完成粘性事件的处理,这就是粘性事件的整个处理流程。

注册订阅者总结:
(1).首先用register()方法注册一个订阅者
(2).获取该订阅者的所有订阅的方法
(3).根据该订阅者的所有订阅的事件类型,将订阅者存入到每个以 事件类型为key 以所有订阅者为values的map集合中
(4).然后将订阅事件添加到以订阅者为key 以订阅者所有订阅事件为values的map集合中
(5).如果是订阅了粘性事件的订阅者,从粘性事件缓存区获取之前发送过的粘性事件,响应这些粘性事件。

2.注销订阅者

下面看下注销订阅者

 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());
        }
    }
    private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
        // 得到当前参数类型对应的Subscription集合
        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对象对应的注册类对象和要取消注册的注册类对象相同,则删除当前subscription对象
                    subscription.active = false;
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

我们可以看到在unregister()方法中,释放了typesBySubscriber、subscriptionsByEventType中缓存的资源。

注销订阅者总结:
(1).首先通过unregister方法拿到要取消的订阅者
(2).得到该订阅者的所有订阅事件类型
(3).遍历事件类型,根据每个事件类型获取到所有的订阅者集合,并从集合中删除该订阅者

3.发送及处理事件

当我们要发送普通事件,就需要用到post()方法,
当我们要发送粘性事件,就需要用到postSticky()方法

//发送普通事件
EventBus.getDefault().post("我要学习EventBus");
//发送粘性事件
EventBus.getDefault().postSticky(new MessageEvent("我要学习EventBus的粘性事件"));
3.1粘性事件 postSticky()方法
    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);
    }

postSticky()方法主要做了两件事,先将事件类型和对应事件保存到stickyEvents中,方便后续使用;然后执行post(event)继续发送事件,这个post()方法就是之前发送普通消息的post()方法。所以,如果在发送粘性事件前,已经有了对应类型事件的订阅者,不是非粘性的,依然可以接收到发送出的粘性事件。

3.2普通事件 post()方法
    public void post(Object event) {
       //currentPostingThreadState是一个PostingThreadState类型的ThreadLocal
       // PostingThreadState类保存了事件队列和线程模式等信息
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        // 将要发送的事件添加到事件队列
        eventQueue.add(event);
        // isPosting默认为false
        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;
            }
        }
    }

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

   private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class<?> eventClass = event.getClass();
        boolean subscriptionFound = false;
        // eventInheritance默认为true,表示是否向上查找事件的父类
        if (eventInheritance) {
            // 查找当前事件类型的Class,连同当前事件类型的Class保存到集合
            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));
            }
        }
    }

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置为初始状态
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

遍历发送的事件类型对应的Subscription集合,然后调用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.enqueue(subscription, event);
                }
                break;
            case MAIN_ORDERED:
                if (mainThreadPoster != null) {
                    // 无论在那个线程发送事件,都先将事件入队列,然后通过 Handler 切换到主线程,依次处理事件。
                    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);
        }
    }

可以看到,postToSubscription()方法就是根据订阅事件方法的线程模式、以及发送事件的线程来判断如何处理事件。
发送事件总结:
(1).首先获取当前线程的事件队列
(2).将要发送的事件添加到事件队列中
(3).根据发送事件类型获取所有的订阅者
(4).根据响应方法的执行模式,在相应线程通过反射执行订阅者的订阅方法

4.Subscribe注解

EventBus3.0 开始用Subscribe注解配置事件订阅方法,不再使用方法名了,如:

 @Subscribe(threadMode = ThreadMode.MAIN)
    public void onShowEventMessage(MessageEvent messageEvent) {
        tvMessage.setText(messageEvent.getMessage());
    }

看下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的属性,文章开始已经介绍了。

关于EventBus的源码就学习到这里,如理解有误,还望指正!

发布了11 篇原创文章 · 获赞 3 · 访问量 4147
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览