EventBus源码详细分析-手写EventBus核心代码

本文由风听雨声授权原创发布

EventBus 是一个面向Android和Java的开源库，使用发布者/订阅者模式实现松散耦合，简化组件之间的通信。使用简单，效率高，体积小。具备高级特性，如传递线程、订阅优先级等，下面是官方的EventBus原理图

EventBus原理图.png

本文将对EventBus（基于当前EventBus最新版本3.2.0）进行详细的源码分析,会有比较详细的代码注释，本文将从以下方面进行展开

• 基本使用简单介绍

• Subscribe注解

• 注册和订阅事件

• 取消注册

• 发送事件

• 处理事件

• 粘性事件

• Annotation的使用方式

• 手写核心代码

基本使用

注册

EventBus.getDefault().register(this);

取消注册

EventBus.getDefault().unregister(this);

发送事件

EventBus.getDefault().post("event");

接收事件

@Subscribe(threadMode = ThreadMode.MAIN)public void subscribeMethod(String event){
}

Subscribe注解

@Documented@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Subscribe {
    ThreadMode threadMode() default ThreadMode.POSTING;


    boolean sticky() default false;
    
    int priority() default 0;
}

运行时作用于方法的注解，注解的value有以下3个

• 1.threadMode():接收事件的线程，默认POSTING，和发送事件同一线程

• 2.sticky():是否为粘性事件，默认false

• 3.priority():接收事件优先级，默认0，即默认所有事件相同优先级

ThreadMode接收事件的线程

public enum ThreadMode {    POSTING,
    MAIN,
    MAIN_ORDERED,
    BACKGROUND,
    ASYNC
}

ThreadMode有以下5种

• 1.POSTING:将在发布事件的同一线程中直接调用订阅者。这是默认设置。事件交付意味着开销最少，因为它完全避免了线程切换。

• 2.MAIN:*在Android上，订阅者将在Android的主线程(UI线程)中被调用。如果发布线程是主线程、订阅方方法将被直接调用，阻塞发布线程。

• 3.MAIN_ORDERED:在Android上，订阅者将在Android的主线程(UI线程)中被调用。与MAIN不同的是事件将一直排队等待交付。这确保了post调用是非阻塞的。

• 4.BACKGROUND:在Android上，订阅者将在后台线程中被调用。如果发布线程不是主线程，订阅方方法将在发布线程中直接调用。如果发布线程是主线程，则EventBus使用后台线程，它将按顺序交付所有事件。

• 5.ASYNC：订阅将在一个单独的线程中被调用。总是独立于发布线程和主线程。

注册和订阅事件

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

Builder设计模式，传入默认Builder

     

  public EventBus() {        this(DEFAULT_BUILDER);
    }


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

默认Builder参数初始值

       

public class EventBusBuilder {    private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();


    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;


    EventBusBuilder() {
    }

注册

1. 获取订阅的class对象

   2.根据订阅的class对象，解析订阅方法Subscribe注解，并封装成SubscriberMethod，加入到
List集合

1. 处理事件

public void register(Object subscriber) {        Class subscriberClass = subscriber.getClass();//1
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//2
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);//3
            }
        }
    }

findSubscriberMethods(Class subscriberClass)

           1.从缓存中取，有直接返回

1. findUsingInfo(subscriberClass)和findUsingReflection(subscriberClass)，两者都是通过反射解析Subscribe，findUsingInfo比findUsingReflection多了FindState的对象池

    3.subscriberMethods加入缓存，以便第二次打开不再需要反射解析

List findSubscriberMethods(Class subscriberClass) {        //先从缓存的Map, List> METHOD_CACHE ，key为注册的class对象，value为List
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }


        if (ignoreGeneratedIndex) {//是否每次都从反射去拿方法参数 ， 默认为false
            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 findUsingInfo(Class subscriberClass) {
        //第一次打开相当于 FindState findState = new FindState()
        FindState findState = prepareFindState();
        //initForSubscriber方法做了以下3点
        //this.subscriberClass = clazz = subscriberClass;
        // skipSuperClasses = false;
        //subscriberInfo = null;
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) { //这里相当于subscriberClass != null
            findState.subscriberInfo = getSubscriberInfo(findState);
            //在这里相当于findState.subscriberInfo = null  会走else
            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 {
                将Subscribe 注解上的参数封装成 SubscriberMethod 添加到 findState.subscriberMethods  List subscriberMethods
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        //return封装好的 annotation 参数ArrayList
        return getMethodsAndRelease(findState);
    }

通过反射解析参数，已加上比较详细的注释

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 获取register的class对象的所有方法，包括私有和抽象
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            try {
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
                String msg = "Could not inspect methods of " + findState.clazz.getName();
                if (ignoreGeneratedIndex) {
                    msg += ". Please consider using EventBus annotation processor to avoid reflection.";
                } else {
                    msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
                }
                throw new EventBusException(msg, error);
            }
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //筛选public方法，且没有static abstract.. 等等修饰符
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                //获取方法参数的class
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {//方法参数数目为1，方法参数大于1不走
                    //获取方法上Subscribe注解
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        //方法参数的class 只有一个，即 parameterTypes[0]
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {//true
                            ThreadMode threadMode = subscribeAnnotation.threadMode();//获取将Subscribe Annotation的threadMode
                            //将Subscribe 注解上的参数封装成 SubscriberMethod 添加到 findState.subscriberMethods  List subscriberMethods
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                    //strictMethodVerification 是否验证参数 抛异常 默认为false
                } 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");
            }
        }
    }

处理事件

           1.优先级排序

1. 处理粘性事件

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {        //方法参数class
        Class eventType = subscriberMethod.eventType;
        // Subscription (register的class subscriber,注解参数subscriberMethod）
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //subscriptionsByEventType HashMap<方法参数Class, CopyOnWriteArrayList>
        //Subscription (register的class subscriber,注解参数subscriberMethod）
        CopyOnWriteArrayList 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);
            }
        }


        //subscriptions.size() == register了eventBus 的class 所有接受 event的方法数目
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                //根据priority 优先级排序
                subscriptions.add(i, newSubscription);
                break;
            }
        }


        //typesBySubscriber HashMap key register EventBus 的 class value subscribedEvents<方法参数的class>
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        //方法参数的class
        subscribedEvents.add(eventType);


        if (subscriberMethod.sticky) {//处理粘性事件
            //把一个Event发送到一个还没有初始化的Activity/Fragment，即尚未订阅事件。
            // 那么如果只是简单的post一个事件，那么是无法收到的，这时候，就需要用到粘性事件
            if (eventInheritance) {//默认为true
                Set, Object>> entries = stickyEvents.entrySet();
                //stickyEvents = new ConcurrentHashMap<>();
                for (Map.Entry, 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);
            }
        }
    }

小结一下
        注册和订阅事件已经走完了，这里主要是EventBus的实例化，并将订阅方法Subscribe注解解析，封装成List findSubscriberMethods。

*取消注册
避免内存泄漏

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


private void unsubscribeByEventType(Object subscriber, Class eventType) {
        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--;
                }
            }
        }
    }

发送事件

public void post(Object event) {        //利用ThreadLocal将PostingThreadState线程安全
        PostingThreadState postingState = currentPostingThreadState.get();
        List