EventBus源码分析

我分析源码一般是从整体来进行分析，对于一些细节的东西，我没有时间也没有能力去分析。

简单使用

导入依赖

implementation'org.greenrobot:eventbus:3.1.1'

定义观察者

public class MyObserver1 {
    public MyObserver1() {
        EventBus.getDefault().register(this);
    }

    @Subscribe
    public void myEvent(MyEvent event){
        System.out.println("我是观察者1，我观察到了");
    }
}

public class MyObserver2 {
    public MyObserver2() {
        EventBus.getDefault().register(this);
    }

    @Subscribe
    public void myEvent(MyEvent event) {
        System.out.println("我是观察者2，我观察到了");
    }
}

定义被观察者和测试

public class MyObserved {
    public MyObserver1 observer1;
    public MyObserver2 observer2;

    public MyObserved() {
        observer1 = new MyObserver1();
        observer2 = new MyObserver2();
    }

    public static void main(String[] args) {
        MyObserved observed = new MyObserved();
        Scanner in = new Scanner(System.in);
        while (true) {
            int code = in.nextInt();
            if (code == 1) {
                observed.sendEvent();
            } else {
                EventBus.getDefault().unregister(observed.observer1);
                EventBus.getDefault().unregister(observed.observer2);
                break;
            }
        }
    }

    public void sendEvent() {
        MyEvent event = new MyEvent();
        EventBus.getDefault().post(event);
    }
}

输出

1
我是观察者1，我观察到了
我是观察者2，我观察到了
1
我是观察者1，我观察到了
我是观察者2，我观察到了
2

具体分析

这里就从上面使用到的方法来进行分析。

入口方法

getDefault()

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

这里就是采用双重校验并加锁(DCL)的单例模式生成EventBus实例。

注册

register()

public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

findSubscriberMethods(Class<?> subscriberClass)

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);
    }
    //。。。省略
}

findUsingReflection(Class<?> subscriberClass)

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
    //...
        findUsingReflectionInSingleClass(findState);
    //...
}

findUsingReflectionInSingleClass(FindState findState)

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    for (Method method : methods) {
        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()));
            }
        }
    } 
    //...
}

以上几个方法的大致逻辑就是先看有没有SubscriberMethod的缓存，有的话直接用，没有的话就找出添加了@Subscribe注解的方法。在findUsingReflectionInSingleClass方法里也可以看到很明显的以反射机制处理注解的逻辑。

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;

    //...
}

从成员变量可以看出这个SubscriberMethod是用来封装观察者的添加了Subscribe注解的方法，观察者有一个观察方法就有一个SubscriberMethod。

最终封装

上面的register方法只看了一部分，还有下面一部分。

public void register(Object subscriber) {
    //...
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

这里将观察者的每个观察方法进行最终封装。

subscribe(Object subscriber, SubscriberMethod subscriberMethod)

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    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);
        }
    }
    //。。。
}

上面的逻辑就是为了避免二次注册，而我省略的部分可以总结为将Subscription添加进容器里。

Subscription类

final class Subscription {
    final Object subscriber;
    final SubscriberMethod subscriberMethod;
    //...
}

主要封装了观察者对象和其方法

EventBus有个关键的成员变量：

private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;

这个Map以事件类型为键，对应的观察方法的容器为值。

而Subscription封装好了之后就是放入这个Map里的。

发送

post()

public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    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主要逻辑就是根据传入的事件，根据其事件类型（Class<?>）从subscriptionsByEventType取出对应事件类型的Subscription，然后利用反射机制，调用方法。

仿EventBus实现

这里就根据上面的分析来实现一个简单的EventBus。

构造单例对象

private HashMap<Class<?>, ArrayList<Observation>> mObserverArrayListHashMap;

private MyEventBus() {
    mObserverArrayListHashMap = new HashMap<>();
}

public static MyEventBus getDefault() {
    return SingletonHolder.SINGLETON;
}

private static class SingletonHolder {
        private static final MyEventBus SINGLETON = new MyEventBus();
    }

这里我采用静态内部类的方式实现单例模式

注册

public void register(Object observer) {
    Class<?> observerClass = observer.getClass();
    List<ObserverMethod> observerMethods = findObserverMethods(observerClass);
    for (ObserverMethod observerMethod : observerMethods) {
        observe(observer, observerMethod);
    }
}

private List<ObserverMethod> findObserverMethods(Class<?> observerClass) {
        List<ObserverMethod> observerMethods = new ArrayList<>();
        for (Method method : observerClass.getDeclaredMethods()) {
            Observe observe = method.getAnnotation(Observe.class);
            if (observe != null) {
                Class<?> eventType = method.getParameterTypes()[0];
                ObserverMethod observerMethod = new ObserverMethod(method, eventType);
                observerMethods.add(observerMethod);
            }
        }
        return observerMethods;
    }
    
private void observe(Object observer, ObserverMethod observerMethod) {
        Class<?> eventType = observerMethod.getEventType();
        Observation observation = new Observation(observer, observerMethod);
        ArrayList<Observation> observations = mObserverArrayListHashMap.get(eventType);
        if (observations == null) {
            observations = new ArrayList<>();
            mObserverArrayListHashMap.put(eventType, observations);
        } else {
            if (observations.contains(observation)) {
                return;
            }
        }
        observations.add(observation);
    }

两个封装类

class ObserverMethod {
    private Method mMethod;
    private Class<?> mEventType;

    public ObserverMethod(Method method, Class<?> eventType) {
        mMethod = method;
        this.mEventType = eventType;
    }

    public Method getMethod() {
        return mMethod;
    }

    public Class<?> getEventType() {
        return mEventType;
    }
}

class Observation {
    private Object observer;
    private ObserverMethod observerMethod;

    public Observation(Object observer, ObserverMethod observerMethod) {
        this.observer = observer;
        this.observerMethod = observerMethod;
    }

    public Object getObserver() {
        return observer;
    }

    public ObserverMethod getObserverMethod() {
        return observerMethod;
    }
}

发送

public void post(Object event) {
    Class<?> eventType = event.getClass();
    ArrayList<Observation> observations = mObserverArrayListHashMap.get(eventType);
    if (observations == null) {
        return;
    }
    for (Observation observation : observations) {
        Object observer = observation.getObserver();
        Method method = observation.getObserverMethod().getMethod();
        try {
            method.invoke(observer, event);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

测试

观察者

public class MyObserver1 {
    public MyObserver1() {
        MyEventBus.getDefault().register(this);
    }

    @Observe
    public void myEvent(MyEvent event){
        System.out.println("我是观察者1，我观察到了");
    }
}

public class MyObserver2 {
    public MyObserver2() {
        MyEventBus.getDefault().register(this);
    }

    @Observe
    public void myEvent(MyEvent event){
        System.out.println("我是观察者2，我观察到了");
    }
}

事件

public class MyEvent {
}

被观察者及测试

public class MyObserved {
    public MyObserved() {
        MyObserver1 observer1 = new MyObserver1();
        MyObserver2 observer2 = new MyObserver2();
    }

    public static void main(String[] args) {
        MyObserved observed = new MyObserved();
        Scanner in = new Scanner(System.in);
        while (true) {
            int code = in.nextInt();
            if (code == 1) {
                observed.sendEvent();
            } else {
                break;
            }
        }
    }

    public void sendEvent() {
        MyEvent event = new MyEvent();
        MyEventBus.getDefault().post(event);
    }
}

output:
1
我是观察者1，我观察到了
我是观察者2，我观察到了
1
我是观察者1，我观察到了
我是观察者2，我观察到了
2

Process finished with exit code 0