EventBus源码分析

EventBus github 地址

在Android Studio中添加如下依赖：

compile 'org.greenrobot:eventbus:3.1.1'

以前在用EventBus之前，一直认为其原理 实现是观察者模式，经过本次分析才发现其原理是不正常的观察者模式，是使用反射加注解的方式实现的。本文章只介绍源码，然后自己手动手写一个类似的 功能。

register源码解析

    public void register(Object subscriber) {
        //获取到注册对象，一般为MainActivity
        Class subscriberClass = subscriber.getClass();
        //这里获取到解析此对象中有Subscribe注解信息列表封装成SubscriberMethod对象
        List subscriberMethods = 
        //此方法比较重要
        subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

其中subscriberMethodFinder为：

    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
             builder.strictMethodVerification, builder.ignoreGeneratedIndex);

其中eventBusBuilder为

    //默认的eventBusBuilder
    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

eventBusBuilder中变量值为，这些值会在下面分析中用到。

    boolean logSubscriberExceptions = true;
    boolean logNoSubscriberMessages = true;
    boolean sendSubscriberExceptionEvent = true;
    boolean sendNoSubscriberEvent = true;
    boolean throwSubscriberException;
    boolean eventInheritance = true;
    boolean ignoreGeneratedIndex;
    boolean strictMethodVerification;
    ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
    List> skipMethodVerificationForClasses;
    List subscriberInfoIndexes;
    Logger logger;
    MainThreadSupport mainThreadSupport;

言归正传，我们回到findSubscriberMethods方法

    List findSubscriberMethods(Class subscriberClass) {
        //从缓存中获取SubscriberMethod对象，第一次应该为空
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //这里默认为false，可以查看builder中数据
        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 findUsingInfo(Class subscriberClass) {
        //享元模式获取对象
        FindState findState = prepareFindState();
        //将返回的对象重新赋值
        findState.initForSubscriber(subscriberClass);
        //当findState.clazz不为空时
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            //因此不会走if
            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

   private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            //获取到类（activity）中所有方法，不包含继承的方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        //遍历类中的方法
        for (Method method : methods) {
            //获取方法的类型
            int modifiers = method.getModifiers();
            //当方法为public时，这里就知道previte方法接收不到的原因了
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                //获取到方法的参数数组，有可能会是多参
                Class[] parameterTypes = method.getParameterTypes();
                //当方法参数为1时才会向下走，这里就知道为啥eventBus只能接收单个参数
                if (parameterTypes.length == 1) {
                    //获取到方法上面的Subscribe注解
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    //如果注解不为空
                    if (subscribeAnnotation != null) {
                        //获取到参数的第一个类型（String.class）
                        Class eventType = parameterTypes[0];
                        //检查数据中是否需要加入此方法和参数类型
                        if (findState.checkAdd(method, eventType)) {
                            //获取到方法上的threadMode
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //将method，eventType，threadMode，priority，sticky加入到集合中
                            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");
            }
        }
    }

这时，我们便把当前类中需要的东西都封装成了SubscriberMethod对象。
其中SubscriberMethod中字段意义为：

    public SubscriberMethod(Method method, Class eventType, ThreadMode threadMode, int priority, boolean sticky) {
        //方法对象
        this.method = method;
        //方法上的threadMode
        this.threadMode = threadMode;
        //方法中参数类(String)
        this.eventType = eventType;
        //方法上priority，优先级
        this.priority = priority;
        //方法上sticky，粘性
        this.sticky = sticky;
    }

进入getMethodsAndRelease方法，获取数据集合。

private List getMethodsAndRelease(FindState findState) {
    //获取到当前subscriberMethods集合
   List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
    //清空findState对象中数据
    findState.recycle();
    synchronized (FIND_STATE_POOL) {
        for (int i = 0; i < POOL_SIZE; i++) {
            if (FIND_STATE_POOL[i] == null) {
                FIND_STATE_POOL[i] = findState;
                break;
            }
        }
    }
    //返回subscriberMethods
    return subscriberMethods;
}

至此findSubscriberMethods方法分析就完成了。可以理解为如下图：

findSubscriberMethods.png

注：图片引用自红橙Darren大神。懒得画了。哈哈哈!

继续分析subscribe方法

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        //获取subscriberMethod中的参数类型
        Class eventType = subscriberMethod.eventType;
        //根据主类(MAinActivity)和SubscriberMethod 创建Subscription 对象
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //从subscriptionsByEventType中获取Subscription list集合，第一次一般为空
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        //当数据为空时，创建list，并且加入到subscriptionsByEventType中
        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);
            }
        }
        //获取到Subscription集合大小
        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;
            }
        }
        //通过类对象(MainActivity)获取到 方法参数(String)集合，第一次为空
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        //创建新数组，并且把数据加入到typesBySubscriber
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        //将本方法参数对象加入到集合中
        subscribedEvents.add(eventType);
        //sticky分析省略
    }

其中Subscription结构为：

    Subscription(Object subscriber, SubscriberMethod subscriberMethod) {
        //主类Mactivity
        this.subscriber = subscriber;
        //类中对应的对象
        this.subscriberMethod = subscriberMethod;
        active = true;
    }

其中用到的变量为：

// subscriptionsByEventType 这个集合存放的是？
// key 是 Event 参数的类
// value 存放的是 Subscription 的集合列表
// Subscription 包含两个属性，一个是 subscriber 订阅者（反射执行对象）,
// 一个是 SubscriberMethod 注解方法的所有属性参数值
private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
// typesBySubscriber 这个集合存放的是？
// key 是所有的订阅者
// value 是所有订阅者里面方法的参数的 class，eventType
private final Map>> typesBySubscriber;

这一部分代码就是根据方法类型进行了分类，如图所示：

• subscriptionsByEventType结构
  
  

  subscriptionsByEventType.png
• typesBySubscriber 结构
  
  

  typesBySubscriber .png

看到这里大家想说了，把这些东西存放到这些结构里面有什么用呢，为什么要这样做呢，那请大家带着这些疑问来看看我们下面讲的unregister

unregister源码解析

当我们再使用EventBus时候在某个类中注册了事件，当不需要接收事件时，我们应该解除注册，这样可以停止接收事件，也为了防止内存泄漏，优化应用。

unregister方法

    public synchronized void unregister(Object subscriber) {
        //获取到本类的方法参数类型集合
        List> 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());
        }
    }

这里就看到了，先从typesBySubscriber数据中获取参数列表

unsubscribeByEventType方法

    private void unsubscribeByEventType(Object subscriber, Class eventType) {
        //从subscriptionsByEventType中获取Subscription
        List 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中获取List数据集，然后移除对应对象。
至此EventBus的register和unregister就讲完了

post源码解析

    public void post(Object event) {
        //获取到当前线程的postingState
        PostingThreadState postingState = currentPostingThreadState.get();
        //获取到当前线程的event事件
        List