EventBus源码分析及仿EventBus实现

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 subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

findSubscriberMethods(Class subscriberClass)

List findSubscriberMethods(Class subscriberClass) {
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);//获取缓存
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    //。。。省略
}

findUsingReflection(Class subscriberClass)

private List 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 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, CopyOnWriteArrayList> subscriptionsByEventType;

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

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

发送

post()

public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List