EventBus是一个非常好的第三方开源库，采用观察者模式，实现事件通知，下载链接为EventBus

重要类和结构

EventBus:主类

  • DEFAULT_BUILDER：EventBusBuilder
    保存配置信息，初始化默认EventBus的时候传入
  • eventTypesCache
    映射关系eventType->eventType的所有祖先
  • subscriptionsByEventType
    映射关系eventType->Subscription列表
  • typesBySubscriber
    映射关系subscriber->eventType列表
  • stickyEvents
    映射关系eventType->event,保存所有sticky event
  • register(Object subscriber)
    通过subscriberMethodFinder获取subscriber注解的method列表，并且更新到subscriptionsByEventType，typesBySubscriber中
  • unregister(Object subscriber)
    主要流程是：将对应信息从typesBySubscriber和subscriptionsByEventType中删除掉，同时标记对应subScriptions.active=false
  • post(Object event)
    将event插入PostingThreadState中的eventQueue中，然后while循环一个一个postSingleEvent
  • cancelEventDelivery(Object event)
    通过postingState.cancel控制当前post的event停止delivery

PostingThreadState

通过ThreadLocal的方式记录线程本地状态，记录字段包括eventQueue，isPosting，isMainThread，subscription，event，canceled

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//摘自EventBus post核心代码
 /** Posts the given event to the event bus. */
    public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List<Object> eventQueue = postingState.eventQueue;
        eventQueue.add(event);
        if (!postingState.isPosting) {
            postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
            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;
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//摘自EventBus 核心代码
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
        CopyOnWriteArrayList<Subscription> subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    postToSubscription(subscription, event, postingState.isMainThread);
                    aborted = postingState.canceled; //可以通过postingState.canceled状态终止event发送
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

Subscription

主要用于绑定subscriber和subscriberMethod

  • active
    标记是否活跃

SubscriberMethodFinder

主要用于获取class中注解的method列表

  • METHOD_CACHE:
    用于缓存解析过的class，查询某个class的注解method列表时，优先查询METHOD_CACHE
  • findUsingInfo
    通过循环class->super class，找每一个class注解的method list

FindState

  • subscriberMethods
    找到的SubscriberMethod列表
  • anyMethodByEventType
    映射关系eventType->method
  • subscriberClassByMethodKey
    映射关系methodKey->declare class

SubscriberMethod

用于记录注解的method，threadMode，eventType，priority，sticky

HandlerPoster，BackgroundPoster，AsyncPoster

  • HandlerPoster：extend Handler
    用于执行主线程事件回调。主要通过handler，sendmessage，handleMessage来处理pendingPostQueue中的数据
  • BackgroundPoster：implements Runnable
    用于执行后台线程事件回调。主要通过 eventBus.getExecutorService()执行pendingPostQueue中的数据
  • AsyncPoster：implements Runnable
    用于执行异步线程事件回调
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//摘自EventBus的核心代码
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC:
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

EventBusAnnotationProcessor

  • methodsByClass
    映射关系 class->methods， 记录注解类中所有注解方法的列表
  • classesToSkip
    记录不可见class的集合
  • process(Set<? extends TypeElement> annotations, RoundEnvironment env)
    通过env，生成methodsByClass和classesToSkip两个集合，然后根据这两个集合信息生成对应的类

学习知识点

Gradle dependency分组

需要给依赖进行分组时，首先需要在configuration中定义分组例如：

1
2
3
4
configurations {
    ...
    deployerJars //定义了依赖分组deployerJars
}

在依赖中，指定依赖分组对应的依赖，例如：

1
2
3
4
dependencies {
    ...
    deployerJars 'org.apache.maven.wagon:wagon-webdav:1.0-beta-2'
}

大型数据对象回收利用机制

  • SubscriberMethodFinder中定义了一个FIND_STATE_POOL，类型是FindState[]， 考虑到每一个FindState包含有多个list，map，每次new需要耗费时间和资源，因此每次使用FindState对象时，先去FIND_STATE_POOL找，有则直接用，没有则新生成一个。当FindState对象使用完时，clear内部资源，set到FIND_STATE_POOL中，进行重复利用
  • PendingPostQueue实现了一个链表队列，队列的项是PendingPost。而PendingPost中定义了一个pendingPostPool用于回收废弃的PendingPost对象。

getDeclaredMethods,getMethods区别

  • getDeclaredMethods：Returns an array of Method objects reflecting all the methods declared by the class or interface represented by this Class object. This includes public, protected, default (package) access, and private methods, but excludes inherited methods.
  • getMethods：Returns an array containing Method objects reflecting all the public member methods of the class or interface represented by this Class object, including those declared by the class or interface and those inherited from superclasses and superinterfaces.

通过ThreadLocal的方式保存线程本地数据

1
2
3
4
5
6
private final ThreadLocal<PostingThreadState> currentPostingThreadState = new ThreadLocal<PostingThreadState>() {
    @Override
    protected PostingThreadState initialValue() {
        return new PostingThreadState();
    }
};

判断当前线程是否为主线程

1
Looper.getMainLooper() == Looper.myLooper()

annotation processors

使用gradle插件android-apt，可以协助Android Studio处理annotation processors，具体做法是：

1
2
3
4
5
6
7
8
9
10
11
12
//配置在Project下的build.gradle中
buildscript {
    dependencies {
        //替换成最新的 gradle版本
        classpath 'com.android.tools.build:gradle:1.3.0'
        //替换成最新android-apt版本
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}
//配置到Module下的build.gradle中
apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'

有些注解处理器需要传递参数，可以通过使用apt.arguments达到此目的，例如：

1
2
3
4
5
apt {
    arguments {
        eventBusIndex "org.greenrobot.eventbusperf.MyEventBusIndex"
    }
}

通过dependencies使用apt，注解处理器的classes将不会添加到你当前的类路径下，仅仅用于注解处理过程。并且会把所有注解处理器生成的source放在IDE的类路径下，方便Android Studio引用，例如：

1
2
3
4
5
dependencies {
    compile project(':EventBus')
    apt project(':EventBusAnnotationProcessor')
    compile 'com.squareup:otto:1.3.8'
}

关于注解解释器的实现具体可以参考注解处理器