EventBus源码分析

s###创建EventBus
EventBus.getDefault() 通过这个方法获取一个默认的对象

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

使用单例设计模式来

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

  public EventBus() {
        this(DEFAULT_BUILDER);
    }

默认的是一个Build的内部类。主要看看里面的参数

 EventBus(EventBusBuilder builder) {
      //订阅事件集合
        subscriptionsByEventType = new HashMap<>();
        //粘性事件
         stickyEvents = new ConcurrentHashMap<>();
           //订阅事件集合
        typesBySubscriber = new HashMap<>();
//主线程处理事件
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
        //background
        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;
    }

配置完基本的属性，来看注册

public void register(Object subscriber) {
//得到这个注册类的class对象
        Class<?> subscriberClass = subscriber.getClass();
        //用于搜索这个注册对象所有注册的事件，以及这个事件的一些属性，比如运行线程，优先级，是否粘性。在订阅的类通过注解的方式来设置。
        //这个方法返回一个注册方法的集合，
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

SubscriberMethodFinder的实现

 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 {
        //根据类的class 来缓存注册方法
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

 private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
 //
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findUsingReflectionInSingleClass(findState);
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(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()));
                        }
                    }
                } 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都已经被保存，通过这个方法getMethodsAndRelease返回， 通过 METHOD_CACHE.put(subscriberClass, subscriberMethods);缓存注解方法。

subscribe()方法的实现

水平太菜实在看不下去了，等以后在慢慢学吧