EventBus原理以及源代码分析

一、概述

　　EventBus是一个基于观察者模式的发布/订阅事件总线框架。将事件的发送者和接收者分开，其可以简化组件之间的通讯，相对于BroadcastReceiver其更轻量级也更易用。

二、用法介绍

　　EventBus的用法非常的简单，大致上就四步：

　　1.注册事件

@Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       /**
        * 注册观察者对象
        */
       EventBus.getDefault().register(this);
   }

　　2.消费事件

/**
    * 用于接收post发送过来的事件
    * @param event 具体的事件主体
    */
   @Subscribe
   public void onMessageEvent(MessageEvent event) {
       switch (event.getArg1()) {
           case 0:
               break;
           case 1:
               break;
 
       }
   }

　　3.取消事件

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

　　4.发送事件

/**
 * 发送消息
 */
public void toPost() {
    MessageEvent event = new MessageEvent();
    event.setArg1(0);
    event.setObj(new Object());
    event.setMsg("我发送消息了");
    EventBus.getDefault().post(event);
}

三、具体的源代码分析

　　1.我们从使用开始入手，先看下EventBus.getDefault(）都干了写什么事情。

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

　　从上面的代码我们可以看出EventBus是一个单例类而且是懒汉式的单例，为了保证整个应用中只有一个EventBus实例。

　　在其构造方法中会进行一些初始化的工作，如：

public EventBus() {
        this(DEFAULT_BUILDER);
    }
 
    EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        //通过订阅事件类型查找订阅对象的map集合
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        //粘性事件
        stickyEvents = new ConcurrentHashMap<>();
        //主线程支持
        mainThreadSupport = builder.getMainThreadSupport();
        //handler对象
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        //runable对象
        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;
        //默认线程，CachedThreadPool
        executorService = builder.executorService;
    }

　　1.subscriptionsByEventType通过event.getClass类型查找HashMap中的subscription集合。而subscription中存放的是subscriberMethod对象，subscriberMethod对象中又存放的是订阅者中用subscriber注解标注的Method、时间类型event.getClass、是否是粘性事件、线程模型、时间执行的优先级等信息。

　　2.mainThreadPoster,其实它是HandlerPoster继承了handler并实现了poster，可以把其理解成主线程handler。调用其enqueue方法传入subscription和subscriber。并在其handleMessage方法中通过eventbus.invokeSubscriber(pendingPost) 放订阅方法在主线程中执行

　　3.BackgroundPoster实现了runnable和poster对象，通过enqueue方法把subscription和subscriber传入，在run方法中执行eventbus.invokeSubscriber(pendingPost)

　　4.AsyncPoster实现了Runnable和Poster接口，也是调用enqueue将Subscription和subscriber传入，并将AsyncPoster对象运行在线程池中，并执行run方法的中的eventBus.invokeSubscriber(pendingPost)

　　5.executorService线程池，其具体实现是CachedThreadPool　　

　　以上的几步在后面的分析中会回使用到。

　　2.EventBus.getDefault().register(this)方法

/**
 * 注册订阅者对象
 * @param subscriber 订阅者
 */
public void register(Object subscriber) {
    //获取订阅者的class对象
    Class<?> subscriberClass = subscriber.getClass();
    //根据订阅者class对象或者订阅者subscribe标注的方法集合SubscriberMethod
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {//加锁，一次只能进一个线程
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            //开始订阅，循环向subscriptionsByEventType中添加订阅对象。具体的做法是，根据事件类型取出订阅集合，然后向订阅集合中不断的加入
            //订阅，并最终存入subscriptionsByEventType中
            subscribe(subscriber, subscriberMethod);
        }
    }
}

　　在register方法内部，会获取到订阅者subscriber（activity）的class对象。并通过这个class对象获取到该订阅者中用subscriber标记的方法集合。通过SubscriberMethodFinder.findSubscriberMethods(subscriberClass)获取。

　　在findSubscriberMethods内部首先会从缓存中获取，如果缓存中又就直接返回，如果缓存中没有就解析subscriberClass对象，并拿到subscriberClass对象中用subscriber注解标注过的方法、方法参数类型、线程模型、事件执行优先级、是否是粘性事件，并将以上信息封装到SubscriberMethod对象中。然后把SubscriberMethod对象加入集合返回。

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        //先从缓存中获取，如果获取到了就直接返回。如果缓存中没有就查找带有subscribe标记的方法，并放到集合中
        //因为一个class对象中用subscribe标注的方法可能不止一个，所以要用集合把所有的都存入进去
        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;
        }
    }

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {//如果订阅者对象不为空，执行下面这个while
            findUsingReflectionInSingleClass(findState);
            //去找父类
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }
 
    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            //利用反射获取subscriber的方法集合
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //过滤public标注的方法
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();//获取参数类型
                //找出只有一个参数的方法
                if (parameterTypes.length == 1) {
                    //找出有subscribe注解的方法
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        //获取事件类型，由于只有一个参数所以parameterTypes取第一个就行了
                        Class<?> eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            //获取线程模型，这个模型用于标注，用户自定义的事件是在主线程中执行还是在子线程中执行
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //把订阅者的方法存入subscriberMethod，并把SubscriberMethod存入方法集合中
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
             ....省略了一些代码
        }
    }

　　然后回过头来看EventBus的findSubscriberMethods方法中的subscriber方法，这个方法是执行订阅操作的。

synchronized (this) {//加锁，一次只能进一个线程
          for (SubscriberMethod subscriberMethod : subscriberMethods) {
              //开始订阅，循环向subscriptionsByEventType中添加订阅对象。具体的做法是，根据事件类型取出订阅集合，然后向订阅集合中不断的加入
              //订阅，并最终存入subscriptionsByEventType中
              subscribe(subscriber, subscriberMethod);
          }
      }

　　循环遍历subscriberMethods集合，并把subscriber和SubscriberMethod封装成Subscription。并把Subscription添加到subscriptions集合。并以eventType为key，subscriptions为value将其缓存到名字为subscriptionsByEventType的HashMap中。

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
       //从subscriberMethod获取事件类型
       Class<?> eventType = subscriberMethod.eventType;
       //将订阅者对象和订阅方法存入Subscription中
       Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
       //先从缓存中取出订阅集合（根据事件类型），如果没有就创建一个
       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;
           }
       }
 
       List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
       if (subscribedEvents == null) {
           subscribedEvents = new ArrayList<>();
           typesBySubscriber.put(subscriber, subscribedEvents);
       }
       subscribedEvents.add(eventType);
 
       ...省略了一些代码
   }

　　到此订阅结束。

　　总结：

　　1.在EventBus中对各个属性进行初始化、如：HashMap、线程池等

　　2.获取subscriber的class对象，并通过SubscriberMethodFinder.findSubscriberMethods(subscriberClass)获取到subscriberClass中用subscriber注解标注的方法属性集合（方法、参数类型、线程模型、是否是粘性事件、事件优先级等）。这里面有一个判断条件，先检查缓存中是否有这些方法集合，如果有就直接返回，如果没有就编辑subscriberClass的方法集合选出用subscriber直接标注的方法，并取出方法、参数类型、线程模型、是否是粘性事件、事件优先级等信息，并将其封装为SubscriberMethod对象，然后将SubscriberMethod对象放入List集合返回。

　　3.对subscriberMethods结合进行遍历，通过subscribe方法进行订阅。在subscribe方法内部会创建一个Subscription对象，并将subscriber对象和SubscriberMethod方法存入。并将Subscription对象加入到CopyOnWriteArrayList集合subscriptions。并以SubscriberMethod.eventType为key，subscriptions为value将数据存入subscriptionsByEventType的HashMap中。到此订阅就结束了。

　　2.EventBus.getDefault().post(event)使用post方法发送订阅通知

public void post(Object event) {
        //从ThreadLocal中取出当前线程中的状态数据
        PostingThreadState postingState = currentPostingThreadState.get();
        //从当前线程中取出事件队列（其实不是队列，就是一个list集合）
        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;
            }
        }
    }

　　在post内部会创建一个PostingThreadState对象和一个消息队列eventQueue。其中PostingThreadState是一个ThreadLocal对象（其可以在不同的线程之间存储数据，且线程间的数据相互独立）

　　并对postingState进行初始化，紧接着会调用postSingleEvent方法，并将事件和postingState传递进去。在postSingleEvent方法内部又会调用postSingleEventForEventType方法。

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;//订阅集合
        synchronized (this) {
            //根据事件类型从订阅map中取出订阅集合
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            //循环遍历订阅集合
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                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;
    }

　　根据eventClass在subscriptionsByEventType的HashMap中取出Subscriptions集合，循环遍历subscriptions集合并通过postToSubscription方法对事件进行分发

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
       switch (subscription.subscriberMethod.threadMode) {//从订阅对象中取出线程模型
           case POSTING://默认模式，在哪个线程中订阅就在哪个线程中执行
               //具体的分发
               invokeSubscriber(subscription, event);
               break;
           case MAIN://如在主线程（UI线程）发送事件，则直接在主线程处理事件；如果在子线程发送事件，则先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。
               if (isMainThread) {
                   invokeSubscriber(subscription, event);
               } else {
                   mainThreadPoster.enqueue(subscription, event);
               }
               break;
           case MAIN_ORDERED://无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件
               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);
       }
   }

　　从上面的代码可以看出根据不同的线程模型会执行不同的方法内容。先看下invokeSubscriber(subscription,event)方法都干了啥

/**
    * 具体执行订阅方法的类
    * @param subscription 订阅对象
    * @param event 事件
    */
   void invokeSubscriber(Subscription subscription, Object event) {
       try {
           //从订阅对象中取出SubscriberMehtod，然后调用其Method方法并执行方法的invoke来完成事件的执行
           subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
       } catch (InvocationTargetException e) {
           handleSubscriberException(subscription, event, e.getCause());
       } catch (IllegalAccessException e) {
           throw new IllegalStateException("Unexpected exception", e);
       }
   }

　　上面方法的执行非常的简单，其实就是从subscription中取出subscriberMethod对象，并取出subscriberMethod对象的method方法并执行method方法的invoke函数。执行完这一段之后在subscriber对象中用subscriber注解标注的方法就会执行了。也就是说到此处未知，从订阅到发送到接收就已经执行完了。

　　上面说的是在那个线程中发送就在哪个线程中接收事件的线程模型。线面说下另外两个，无论如何在主线程中执行和无论如何在子线程中执行。主要看两个类HandlerPoster和BackgroundPoster这个两个为代表讲解一下。

　　先看HandlerPoster

public class HandlerPoster extends Handler implements Poster {
　　.....省略了一些代码
    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            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) {
               ...省略了一些代码
                eventBus.invokeSubscriber(pendingPost);
                ....省略了一些代码
}

　　如果再子线程发送事件，然后想让在在主线程中执行。那么首先就要调用HandlerPoster.enqueue方法，enqueue方法内部会调用sendMessage向主线程Handler发送消息，在Handler的handleMessage内部会接收消息通知，并执行eventBus.invokeSubscriber(pendingPost)。看到这一步其实就明了了，就是通过反射执行方法呗，不同的是执行过程已经切换到主线程了。

　　再来看一下BackgroundPoster这个类。

final class BackgroundPoster implements Runnable, Poster {
 
    ...省略了一些diamante
    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) {
                   ...省略了一些代码
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }
 
}

　　从以上的源代码我们可以看出BackgroundPoster实现了Runnable和poster接口，并实现run方法和enqueue方法。在enqueue的内部会调用eventbus的线程池的execute(this)方法运行BackgroundPoster对象的run方法，在run方法内部会调用eventBus.invokeSubscriber(pendingPost)方法，这个方法目的非常明确，通过反射执行subscriber对象中用subscriber注解标注的方法。

　　总结：

　　1.在post方法内部对postingThreadState进行初始化并赋值

　　2.调用postSingleEvent方法，在postSingleEvent方法内部调用postSingleEventForEventType方法，在postSingleEventForEventType方法内部根据eventType从subscriptionsByEventType中取出Subscriptions集合。循环遍历Subscriptions集合，并执行postToSubscription方法。在postToSubscription方法内部会根据不同的现场模型执行对应的方法。如：1.直接执行invokeSubscriber(subscription,eventObj) ,2.通过HandlerPoster.enqueue将执行事件切换到主线程中执行，最终也是会执行invokeSubscriber(pendingPost)方法，3.通过BackgroundPoster.enqueue方法将时间切换到子线程或者线程池中执行，最终会在run方法中执行eventBus.invokeSubscriber(pendingPost)方法。以上三步最终都会调用subscription.subscriberMethod.method.invoke(subscriptions.subscriber,eventObj),完成最终的执行，执行时subscriber注解标注的方法会被执行。

3.我们接下来看下事件的接收，即用subscriber注解标注的方法。其实不用看这个方法，因为这个方法可以自定义只要符合规则就行。主要看一下Subscriber注解的定义和ThreadMode的定义加深对注解和线程模型的理解。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    //指定订阅事件在哪个线程中运行,默认是POSTING，即在哪个线程中发送就在哪个线程中接收
    ThreadMode threadMode() default ThreadMode.POSTING;
    //粘性事件，默认为false
    boolean sticky() default false;
    //订阅事件执行的优先级
    int priority() default 0;
}

/**
 * EventBus线程模型
 */
public enum ThreadMode {
    /**
     * 在哪个线程中发送事件就在哪个线程中接收事件
     */
    POSTING,
    /**
     * 如果实在主线程中发送事件就在主线程中处理，如果再子线程中发送事件就把事件先如队列，然后通过handler切换到主线程中处理
     */
    MAIN,
    /**
     * 无论在主线程还是子线程中发送事件，都将事件先入队列，然后通过Handler切换到主线程，依次处理事件。
     */
    MAIN_ORDERED,
    /**
     * 如果再主线程中发送事件，则将事件入队列，在线程池中依次执行。如果在子线程中发送事件，则直接在发送事件的线程中处理事件。
     */
    BACKGROUND,
    /**
     * 无论是在主线程还是在子线程中发送事件，都把时间入队列，通过线程池依次执行
     */
    ASYNC
}

　　不多说，注释非常的清晰了。

4.接下来看一下事件是如何取消注册的，即EventBus.getDefault().unRegister(this)

public synchronized void unregister(Object subscriber) {
      List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
      if (subscribedTypes != null) {
          for (Class<?> eventType : subscribedTypes) {
              unsubscribeByEventType(subscriber, eventType);
          }
          typesBySubscriber.remove(subscriber);
      } else {
          logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
      }
  }　

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

　　注册这块非常的简单就分两步：1.移除typesBySubscriber集合中的对象。2.通过eventType从subscriptionsByEventType中取出Subscriptions集合，然后找到和subscriber相等的Subscription.subscriber，然后将其从集合中移除掉就行了。

总结：再总结一下这个三大流程做一个汇总

　　1.注册

　　　　注册是通过EventBus.getDefault().register(this)来完成的，

　　　　a.其首先获取到订阅者subscriber的class对象。

　　　　b.通过SubscriberMethodFinder对象的findSubscriberMethod获取订阅者方法集合（List<SubscriberMethod>）,在这个方法中首先会根据subscriber.getClass为key检查METHOD_CACHE,Map集合中是否有缓存对象，如果有就直接返回，如果没有就解析subscriber.getClass()对象中用subscribe注解标注的方法，并从中取出Method、参数类型（eventType）、线程模型ThreadMode、是否是粘性事件、事件的优先级，并将这几个值封装到SubscriberMethod中，然后把SubscriberMethod对象存储到List<SubscriberMethod> subscriberMethods集合中，再以subscriber.getClass()为key，subscriberMethods为value存入METHOD_CACHE集合中，最后返回一个List<SubscriberMethod> subscriberMethods的集合。

　　　　c.遍历subscriber集合并通过subscribe实现真正的订阅。在subscribe方法中会创建一个Subscription对象，并将subscriber和subscriberMethod存入Subscription对象，然后把Subscription对象存入CopyOnWriteArrayList<Subscription> subscriptions集合，并以subscription.subscriberMethod.eventType为key，subscriptions为value存入subscriptionsByEventType。以subscriber为key，List<Class<?>> subscribedEvents 为value将订阅者和事件类型关联到HashMap<subscriber,eventType> typesBySubscriber集合，到此注册订阅者就全部完成了。

　　2.发送

　　　　发送事件是从EventBus.getDefault().post(obj)开始的

　　　　a.在post方法内部会首先初始化PostingThreadState（这个对象用ThreadLocal来存储的）。如：当前线程类型、队列等。然后会调用postSingleEvent方法，在postSingleEvent方法内部又会调用postSingleEventForEventType方法

　　　　b.在postSingleEventForEventType方法内部会从subscriptionsByEventType集合中根据eventClass取出Subscriptions集合。然后循环遍历Subscriptions集合，并循环调用postToSubscription方法

　　　　c.在postToSubscription方法内部会根据不同的线程模型执行不同的操作，如：MAIN，BACKGROUND等。最终都会调用eventBus.invokeSubscriber()方法，在invokeSubscriber内部会通过反射执行被subscriber注解标注过的方法，如：subscription.subscriberMethod.method.invoke(subscription.subscriber,eventObj).

　　3.接收

　　　　接收方法使用subscriber注解标注的自定义方法，非常简单，不再赘述。

　　4.取消注册

　　　　取消是通过EventBus.getDefault().unRegister(this)

　　　　a.首先根据句subscriber对象拿到typesBySubscriber Map集合。并取出List<Class<?> subscriberTypes集合

　　　　b.循环遍历subscriberTypes集合，然后以eventTypeClass为key从subscriptionsByEventType集合中获取到subscriptions集合。循环遍历subscriptions集合取出subscription.subscriber==subscriber相等的，然后移除掉缓存。

　　　　c.根据subscriber为key，移除掉typesBySubscriber集合中的缓存的eventTypes集合。

　　　　到此取消注册也就结束了。

posted on 2020-03-10 23:51 飘杨...... 阅读(631) 评论(0) 编辑收藏举报

EventBus原理以及源代码分析

搜索

常用链接

我的标签

随笔分类

随笔档案

文章分类

阅读排行榜

评论排行榜

推荐排行榜

最新评论