项目到了一定阶段会出现一种甜蜜的负担：业务的不断发展与人员的流动性越来越大，代码维护与测试回归流程越来越繁琐。这个时候需要对项目进行两方面的重构：
1.分层操作，方便复用
2.模块解耦，减少影响
小英团队经过多次调研之后有如下成果：
分层操作
下图是项目的分层模型：
ProgectUI：界面展示层，包括各个Activity，Fragment页面，以及相对复杂的一些UI组件等
Bussiness：实际业务层，比如：用户点击登录按钮，去执行登录的操作
BussinessService：业务服务层，对外提供数据服务。比如：用户信息模块对外提供用户相关的所有信息
Interface层：网络请求与数据缓存层；将用户的网络接口单独作为一层，并根据实际需要设置是否进行缓存。
DbCache层：数据库与数据模型转换层；所有数据库操作都使用DbCache；
CoreService层：功能同FrameWork层，但是较重，故拆出；CoreService与FrameWork层具备业务无关性、通用性；主要有：分发器，Hybrid，热修复以及埋点等
FrameWork层：基础的技术组件（网络库，图片库等）、三方服务封装以及通用UI等；
以用户信息模块为例，介绍一下具体的实现过程：
ProgectUI对应NewLoginActivity：界面展示层，登录页面，通过ChrLoginView与业务逻辑解耦
Bussiness对应QuickLoginPresenter：实际业务层，用户注册、登录、忘记密码等操作；依赖View与Module,处理实际的业务逻辑
BussinessService对应UserInstance：业务服务层.存储账号信息与用户信息。通过实现接口UserInfoInterface,向外提供用户信息服务。
Interface对应ApiService：登录相关的后台接口。
FrameWork对应ApiUtils:封装网络库Retrofit,代理网络请求
模块解耦
总体采用依赖注入的方式将服务的实现与使用分离：
UserInstance维护用户模块所有的信息，并通过UserInfoInterface与其他模块进行隔离
ServiceManager负责维护各个模块服务的注册并提供访问的接口
UserBean实体bean作为数据通信的格式，负责统计用户模块所有的信息
EventBus消息总线负责向外提供本模块的方法调用
总体思想：依赖注入负责对外暴露数据；EventBus负责对外暴露回调方法。
接下来就来介绍本文的主体：EventBus
简单介绍
EventBus-Android端事件发布/订阅框架，特点如下：
简化组件之间的通信。Android常用的通信方式：Broadcast、Listener、静态变量以及通过Handler进行线程之间的通信等。都可以统一使用EventBus。
简化代码。不同于使用Listener通信方式，层层传递，模块之间耦合严重。EventBus使用非常简单并且无耦合
高性能。框架中采用缓存、池化技术、细粒度锁、索引加速等方式使开发者无需关注安全性能方面的问题
依赖包不足50k
高级属性：线程模型、优先级以及是否接收粘性事件等
总线的工作机制如图：
订阅者通过EventBus订阅相关事件，并准备好回调方法
发布者将事件发送给post出去，EventBus负责通知订阅者
极简使用
分为五步：导入依赖、初始化总线、定义事件、注册订阅者、发送事件
导入依赖
项目中Module的build.gradle中添加依赖：
compile 'org.greenrobot:eventbus:3.0.0’
如果不需要索引加速，直接跳到第二步。
索引加速使用到编译时注解，所以需要在项目gradle中添加apt编译插件：
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8’
在Module中申请apt插件生成索引的完整类名
apply plugin: 'com.neenbedankt.android-apt'
apt {
arguments {
eventBusIndex “com.chinahrMyEventBusIndex"
}
}
Module中引入EventBusAnnotationProcessor:
apt 'org.greenrobot:eventbus-annotation-processor:3.0.1’
编译项目之后，就可以在\app\build\generate\source\apt下看到生成的索引类
初始化总线
EventBus可以通过getDefault()方法获取单例
EventBus.getDefault().register(this);
也可以通过EventBus.builder()去构造自定义的EventBus。另外还可以通过Bulder.installDefaultEventBus()修改默认的单例
EventBus.builder().eventInheritance(true).installDefaultEventBus();
如果需要索引加速，将编译时生成的Index通过Builder添加进去
EventBus.getDefault().builder().addIndex(new MyEventBusIndex());
定义事件
所有可以被实例化成object的类都可以作为事件
public class MyEvent {
}
注册订阅者
订阅事件的类中执行register()
EventBus.getDefault().register(this);
并在监听事件的回调方法上添加注解@SubScribe，可配置属性：方法执行的线程模型，分发的优先级，是否接收粘性事件
@Subscribe(threadMode = ThreadMode.MAIN,priority = 0,sticky = true)
public void onEventLogin(MyEvent myEvent){
Toast.makeText(MainActivity.this,"登录成功",Toast.LENGTH_LONG).show();
}
为了防止内存泄露，在总线中对订阅者进行注销，比如在Activity的OnDestroy()中：
EventBus.getDefault().unregister(this);
发送事件
调用post(myEvent)或postSticky(myEvent)
EventBus.getDefault().post(new MyEvent());
以上完成了消息订阅/发布的整个流程。
接下来将会说明框架内部的结构：
整体框架
四部分组成，如图：
数据元素
框架主要涉及这些数据元素：订阅者Subscriber,方法主体Method,事件event,事件类型eventType,线程模型ThreadMode,方法优先级priority,是否接收粘性事件sticky
SubscriberMethod与订阅者subscriber组合成Subscription,即订阅方法。
一个方法的执行需要方法主体（Method)，调用方法的对象(Subscriber),参数（事件event)
post(event)之后结合Subscription就可以完成Method的调用。
EventBus
框架的门面,维护三个Map，并负责分发事件与执行订阅方法。
Map, CopyOnWriteArrayList>subscriptionsByEventType.事件类型与订阅方法列表的对应关系。注册事件，发送事件都是在操作此map.
Map>>typesBySubscriber.订阅者与订阅事件类型的对应关系。为了方便注销订阅者。
Map, Object>stickyEvents.粘性事件列表
调度器
回调方法通过四种方式进行分发，即线程模型ThreadMode:
POSTING:默认模式，直接在当前线程执行
MAIN:如果当前是主线程，直接执行；如果不是主线程，通过handler发送到主线程执行。
BACKGROUND:如果是主线程，交给backgroundPoster去调度；如果不是主线程就直接执行。
ASYN:交给asyncPoster调度。asyncPoster会直接在线程池当中开启一个线程执行。
索引加速
编译时，apt插件通过EventBusAnnotationProcessor提取注解@Subscribe生成索引MyEventBusIndex.索引内部维护一个Map，辅助EventBus查找方法信息
Map, SubscriberInfo>SUBSCRIBER_INDEX.订阅者的类型与回调方法列表对应关系
整个流程一句话总结：在订阅者准备好处理事件的回调方法之后，EventBus根据订阅者对象经过反射或者索引加速获取回调方法的信息，接收发布的事件event,按照指定的线程模型执行回调方法。
EventBus内部设计十分精致，对于编程技能的提高有非常大的帮助。接下来介绍：
设计思想
作为一个框架主要有四方面的设计：门面、调度器、线程安全、性能调优等
门面
1.EventBus类，门面模式中的门面类对外提供集中化和简化的沟通管道。总线的所有操作（注册订阅者，发送事件，调度执行，注销订阅者等）被封装到EventBus中，有效地屏蔽实现细节，使用和维护起来非常方便。
public classEventBus {
/**
* Registers the given subscriber to receive events. Subscribers must call {@link#unregister(Object)} once they
* are no longer interested in receiving events.
*
* Subscribers have event handling methods that must be annotated by {@linkSubscribe}.
* The {@linkSubscribe} annotation also allows configuration like {@link
* ThreadMode} and priority.
*/
public void register(Object subscriber) {Class subscriberClass = subscriber.getClass();
List subscriberMethods =subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized(this) {
for(SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
/** Posts the given event to the event bus. */
public voidpost(Object event) {
PostingThreadState postingState =currentPostingThreadState.get();
List eventQueue = postingState.eventQueue;
eventQueue.add(event);
if(!postingState.isPosting) {
postingState.isMainThread= Looper.getMainLooper() == Looper.myLooper();
postingState.isPosting=true;
if(postingState.canceled) {
throw newEventBusException("Internal error. Abort state was not reset");
}
try{
while(!eventQueue.isEmpty()) {
postSingleEvent(eventQueue.remove(0), postingState);
}
}finally{
postingState.isPosting=false;
postingState.isMainThread=false;
}
}
}
voidinvokeSubscriber(Subscription subscription, Object event) {
try{
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
}catch(InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
}catch(IllegalAccessException e) {
throw newIllegalStateException("Unexpected exception", e);
}
}
/** Unregisters the given subscriber from all event classes. */
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{
Log.w(TAG,"Subscriber to unregister was not registered before: "+ subscriber.getClass());
}
}
}
2.EventBus对象的构建，采用volatile实例与双重检查加锁方式保证线程安全。
static volatileEventBusdefaultInstance;
/** Convenience singleton for apps using a process-wide EventBus instance. */
public staticEventBus getDefault() {
if(defaultInstance==null) {
synchronized(EventBus.class) {
if(defaultInstance==null) {
defaultInstance=newEventBus();
}
}
}
returndefaultInstance;
}
3.采用Builder模式辅助构建实例，避免因构造参数多带来的构造器繁多，即避免重复重叠构造器模式；也避免了采用javaBean封装参数带来的修改一致性问题。
public classEventBus {
private static finalEventBusBuilderDEFAULT_BUILDER=newEventBusBuilder();
EventBus(EventBusBuilder builder) {
subscriptionsByEventType=newHashMap<>();
typesBySubscriber=newHashMap<>();
stickyEvents=newConcurrentHashMap<>();
mainThreadPoster=newHandlerPoster(this, Looper.getMainLooper(),10);
backgroundPoster=newBackgroundPoster(this);
asyncPoster=newAsyncPoster(this);
indexCount= builder.subscriberInfoIndexes!=null? builder.subscriberInfoIndexes.size() :0;
subscriberMethodFinder=newSubscriberMethodFinder(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 staticEventBusBuilder builder() {
return newEventBusBuilder();
}
}
public classEventBusBuilder {
/** Default: true */
publicEventBusBuilder logSubscriberExceptions(booleanlogSubscriberExceptions) {
this.logSubscriberExceptions= logSubscriberExceptions;
return this;
}
/** Builds an EventBus based on the current configuration. */
publicEventBus build() {
return newEventBus(this);
}
}
4.构造方法采用public,可以构建在项目中对不同的子模块创建消息总线。Builder中提供修改默认单例的方法installDefaultEventBus(),是全局单例更加灵活。
public classEventBus {
/**
* Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
* central bus, consider {@link#getDefault()}.
*/
publicEventBus() {
this(DEFAULT_BUILDER);
}
}
public classEventBusBuilder {
* Installs the default EventBus returned by {@linkEventBus#getDefault()} using this builders' values. Must be
* done only once before the first usage of the default EventBus.
*
*@throwsEventBusException if there's already a default EventBus instance in place
*/
publicEventBus installDefaultEventBus() {
synchronized(EventBus.class) {
if(EventBus.defaultInstance!=null) {
throw newEventBusException("Default instance already exists."+
" It may be only set once before it's used the first time to ensure consistent behavior.");
}
EventBus.defaultInstance= build();returnEventBus.defaultInstance;
}
}
}
总结一句话：EvntBus作为框架的门面，采用双检锁,builder模式,构造参数public，封装流程细节，使得总线可以灵活配置与统一管理。
数据结构Map化
利用对象的class属性作为Map的key值可以使代码更加简洁。这也是只需要传入一个对象就可以驱动整个流程运行起来的关键。
private finalMap, CopyOnWriteArrayList>subscriptionsByEventType;
private finalMap>>typesBySubscriber;
private finalMap, Object>stickyEvents;
// Must be called in synchronized block
private voidsubscribe(Object subscriber, SubscriberMethod subscriberMethod) {
…………
…………
…………
if(subscriberMethod.sticky) {
if(eventInheritance) {
// Existing sticky events of all subclasses of eventType have to be considered.
// Note: Iterating over all events may be inefficient with lots of sticky events,
// thus data structure should be changed to allow a more efficient lookup
// (e.g. an additional map storing sub classes of super classes: Class -> List).
Set, Object>> entries =stickyEvents.entrySet();
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);
}
}
}
public voidpostSticky(Object event) {
synchronized(stickyEvents) {
stickyEvents.put(event.getClass(), event);
}
// Should be posted after it is putted, in case the subscriber wants to remove immediately
post(event);
}
这个可以借鉴到组件化设计当中的服务管理器ServiceManager,维护一个以服务接口类为key，实现类作为value的Map。简化注册调用方法。
public classServiceManager {
Map serviceMap=new HashMap<>();static volatileServiceManagerdefaultInstance;
public staticServiceManager getInstance(){
if(defaultInstance==null){
synchronized(ServiceManager.class){
if(defaultInstance==null){
defaultInstance=newServiceManager();
}
}
}
returndefaultInstance;
}
public voidregister(Object serviceInstance){
serviceMap.put(serviceInstance.getClass().getInterfaces()[0],serviceInstance);
}
publicTgetService(Class serviceType){
return(T)serviceMap.get(serviceType);
}
}
public interfaceUserinfoInterface {
publicUserBean getUserInfo();
}
注册服务
public classUserInstanceimplementsUserinfoInterface {
UserInstance(){
ServiceManager.getInstance().register(this);
}
@Override
publicUserBean getUserInfo() {
return newUserBean();
}
}
其他模块调用用户信息：
public classResumeInstance {
voiddoSomeThing(){
UserinfoInterface userinfoInterface=ServiceManager.getInstance().getService(UserinfoInterface.class);
if(userinfoInterface!=null)
userinfoInterface.getUserInfo();
}
}
调度器
Android的线程有个特点：主线程不能被阻塞，UI的更新位于主线程，耗时操作如网络处理在后台线程
框架采用下面的方式进行调度：
每个调度器都维护一个待处理方法队列PendingPostQueue。值得一提的是：poll(intmaxMillisToWait)出队时如果当前队列为空，会释放当前对象的锁，等待队列填充。这个功能将在下面性能分析时解释
final classPendingPostQueue {
privatePendingPosthead;
privatePendingPosttail;
synchronized voidenqueue(PendingPost pendingPost) {
if(pendingPost ==null) {
throw newNullPointerException("null cannot be enqueued");
}
if(tail!=null) {
tail.next= pendingPost;
tail= pendingPost;
}else if(head==null) {
head=tail= pendingPost;
}else{
throw newIllegalStateException("Head present, but no tail");
}
notifyAll();
}
synchronizedPendingPost poll() {
PendingPost pendingPost =head;
if(head!=null) {
head=head.next;
if(head==null) {
tail=null;
}
}
returnpendingPost;
}
synchronizedPendingPost poll(intmaxMillisToWait)throwsInterruptedException {
if(head==null) {
wait(maxMillisToWait);
}
returnpoll();
}
}
HandlerPoster负责在主线程中处理事件，显然它是Handler的子类
final classHandlerPosterextendsHandler {
private finalPendingPostQueuequeue;
private final intmaxMillisInsideHandleMessage;
private finalEventBuseventBus;
private booleanhandlerActive;
HandlerPoster(EventBus eventBus, Looper looper,intmaxMillisInsideHandleMessage) {
super(looper);
this.eventBus= eventBus;
this.maxMillisInsideHandleMessage= maxMillisInsideHandleMessage;
queue=newPendingPostQueue();
}
voidenqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized(this) {
queue.enqueue(pendingPost);
if(!handlerActive) {
handlerActive=true;
if(!sendMessage(obtainMessage())) {
throw newEventBusException("Could not send handler message");
}
}
}
}
@Override
public voidhandleMessage(Message msg) {
booleanrescheduled =false;
try{
longstarted = SystemClock.uptimeMillis();
while(true) {
PendingPost pendingPost =queue.poll();
if(pendingPost ==null) {
synchronized(this) {
// Check again, this time in synchronized
pendingPost =queue.poll();
if(pendingPost ==null) {
handlerActive=false;
return;
}
}
}
eventBus.invokeSubscriber(pendingPost);
longtimeInMethod = SystemClock.uptimeMillis() - started;
if(timeInMethod >=maxMillisInsideHandleMessage) {
if(!sendMessage(obtainMessage())) {
throw newEventBusException("Could not send handler message");
}
rescheduled =true;
return;
}
}
}finally{
handlerActive= rescheduled;
}
}
}
BackgroundPoster继承自Runnable，某一时段内待处理都会在BackgroundPoster的run方法中排队处理。BackgroundPoster正在被线程池执行时，executorRunning==true，此时发布的事件只会进队列，不会再次调用线程池的execute方法。事件全部处理后才退出死循环，设置executorRunning=fasle，此后再发布事件才会在线程池中开辟一个新线程。
上文提到（PendingPostQueue.poll(int)）在队列为空的时候等待队列中添加元素。以及executorRunning标示位的使用，都是为了重用当前对象。
final classBackgroundPosterimplementsRunnable {
private finalPendingPostQueuequeue;
private finalEventBuseventBus;
private volatile booleanexecutorRunning;
BackgroundPoster(EventBus eventBus) {
this.eventBus= eventBus;
queue=newPendingPostQueue();
}
public voidenqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
synchronized(this) {
queue.enqueue(pendingPost);
if (!executorRunning) {
executorRunning = true;
eventBus.getExecutorService().execute(this);
}
}
}
@Override
public voidrun() {
try{
try{
while(true) {
PendingPost pendingPost = queue.poll(1000);
if(pendingPost ==null) {
synchronized(this) {
// Check again, this time in synchronized
pendingPost =queue.poll();
if(pendingPost ==null) {
executorRunning=false;
return;
}
}
}
eventBus.invokeSubscriber(pendingPost);
}
}catch(InterruptedException e) {
Log.w("Event", Thread.currentThread().getName() +" was interruppted", e);
}
}finally{
executorRunning=false;
}
}
}
AyncPoster很简单，来了事件就在线程池中开辟线程执行。
classAsyncPosterimplementsRunnable {
private finalPendingPostQueuequeue;
private finalEventBuseventBus;
AsyncPoster(EventBus eventBus) {
this.eventBus= eventBus;
queue=newPendingPostQueue();
}
public voidenqueue(Subscription subscription, Object event) {
PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
queue.enqueue(pendingPost);
eventBus.getExecutorService().execute(this);
}
@Override
public voidrun() {
PendingPost pendingPost =queue.poll();
if(pendingPost ==null) {
throw newIllegalStateException("No pending post available");
}
eventBus.invokeSubscriber(pendingPost);
}
}
总体一句话：三种方式的线程模型与一个方法链表组成一个非常标准Android版线程调度器。
线程安全
框架在应对多线程方面做了很多设计
1.粒度锁
public classEventBus {
private finalMap, CopyOnWriteArrayList>subscriptionsByEventType;
private finalMap>>typesBySubscriber;
private finalMap, Object>stickyEvents;
public voidregister(Object subscriber) {
Class subscriberClass = subscriber.getClass();
List subscriberMethods =subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
subscribe(subscriber, subscriberMethod);
}
}
}
private booleanpostSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
CopyOnWriteArrayList subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(eventClass);
}
…………
}
public booleanhasSubscriberForEvent(Class eventClass) {
List> eventTypes =lookupAllEventTypes(eventClass);
if(eventTypes !=null) {
intcountTypes = eventTypes.size();
for(inth =0; h < countTypes; h++) {
Class clazz = eventTypes.get(h);
CopyOnWriteArrayList subscriptions;
synchronized (this) {
subscriptions = subscriptionsByEventType.get(clazz);
}
if(subscriptions !=null&& !subscriptions.isEmpty()) {
return true;
}
}
}
return false;
}
}
只在使用到需要同步的数据结构时，才去synchronized(this)，获取当前对象锁。另外，对于在部分流程才会使用的数据结构并不会占用当前对象锁,比如：stickyEvents,但问题就出在这里,stickyEvents是ConcurrentHashMap线程安全的，并且粒度比当前对象小。
public classEventBus {
private finalMap, Object>stickyEvents;
public voidpostSticky(Object event) {
synchronized (stickyEvents) {
stickyEvents.put(event.getClass(), event);
}
// Should be posted after it is putted, in case the subscriber wants to remove immediately
post(event);
}
publicTgetStickyEvent(Class eventType) {
synchronized (stickyEvents) {
return eventType.cast(stickyEvents.get(eventType));
}
}
EventBus(EventBusBuilder builder) {
subscriptionsByEventType=newHashMap<>();
typesBySubscriber=newHashMap<>();
stickyEvents = new ConcurrentHashMap<>();
mainThreadPoster=newHandlerPoster(this, Looper.getMainLooper(),10);
backgroundPoster=newBackgroundPoster(this);
asyncPoster=newAsyncPoster(this);
indexCount= builder.subscriberInfoIndexes!=null? builder.subscriberInfoIndexes.size() :0;
subscriberMethodFinder=newSubscriberMethodFinder(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;
}
2.数据结构的合理使用。
方法列表采用CopyOnWriteArrayList,CopyOnWrite容器即写时复制的容器。通俗的理解是当往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。缺点就是会造成内存占用双份，以及数据一致性问题（CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。）考虑到方法只会在注册的时候进行添加，因此采用偏缓存性质的数据结构更适合于当前的应用场景。
线程状态信息采用ThreadLocal类型进行保存,ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。
public classEventBus {
private finalMap,CopyOnWriteArrayList>subscriptionsByEventType;
private finalThreadLocalcurrentPostingThreadState=newThreadLocal() {
@Override
protectedPostingThreadState initialValue() {
return newPostingThreadState();
}
};
总结一句话：通过synchronized与ThreadLocal的数据类型，构建出线程安全以及简洁优美的代码。
高性能
1.索引加速
总线注册时只传入通过注解标记回调方法的订阅者对象。EventBus把获取订阅方法的过程放在编译时，避免运行时反射带来的性能问题
@SupportedAnnotationTypes("org.greenrobot.eventbus.Subscribe")
@SupportedOptions(value = {"eventBusIndex", "verbose"})
public class EventBusAnnotationProcessor extends AbstractProcessor {
/** Found subscriber methods for a class (without superclasses). 被注解表示的方法信息 */
private final ListMap methodsByClass = new ListMap<>();
private final Set classesToSkip = new HashSet<>(); // checkHasErrors检查出来的异常方法
@Override
public boolean process(Set annotations, RoundEnvironment env) {
Messager messager = processingEnv.getMessager();
try {
String index = processingEnv.getOptions().get(OPTION_EVENT_BUS_INDEX);
if (index == null) { // 如果没有在gradle中配置apt的argument，编译就会在这里报错
messager.printMessage(Diagnostic.Kind.ERROR, "No option " + OPTION_EVENT_BUS_INDEX +
" passed to annotation processor");
return false;
}
/** ... */collectSubscribers(annotations, env, messager);// 根据注解拿到所有订阅者的回调方法信息checkForSubscribersToSkip(messager, indexPackage);// 筛掉不符合规则的订阅者
if (!methodsByClass.isEmpty()) {createInfoIndexFile(index);// 生成索引类
}
/** 打印错误 */
}
/** 下面这些方法就不再贴出具体实现了，我们了解它们的功能就行 */
private void collectSubscribers // 遍历annotations，找出所有被注解标识的方法，以初始化methodsByClass
private boolean checkHasNoErrors // 过滤掉static，非public和参数大于1的方法
private void checkForSubscribersToSkip // 检查methodsByClass中的各个类，是否存在非public的父类和方法参数
/** 下面这三个方法会把methodsByClass中的信息写到相应的类中 */
private void writeCreateSubscriberMethods
private void createInfoIndexFile
private void writeIndexLines
}
获取所有订阅者的回调方法信息之后，生成Index。运行时就可直接使用Map去查找回调方法。
packagecom.example.wangbinlong.myapplication;
importorg.greenrobot.eventbus.meta.SimpleSubscriberInfo;
importorg.greenrobot.eventbus.meta.SubscriberMethodInfo;
importorg.greenrobot.eventbus.meta.SubscriberInfo;
importorg.greenrobot.eventbus.meta.SubscriberInfoIndex;
importorg.greenrobot.eventbus.ThreadMode;
importjava.util.HashMap;
importjava.util.Map;
/** This class is generated by EventBus, do not edit. */
public classMyEventBusIndeximplementsSubscriberInfoIndex {
private static final Map, SubscriberInfo>SUBSCRIBER_INDEX;
static {
SUBSCRIBER_INDEX= new HashMap, SubscriberInfo>();
putIndex(new SimpleSubscriberInfo(MainActivity.class, true, new SubscriberMethodInfo[] {
new SubscriberMethodInfo("onLogin", EventBusManager.LoginEvent.class, ThreadMode.MAIN),
}));
putIndex(new SimpleSubscriberInfo(SecondActivity.Inner.class, true, new SubscriberMethodInfo[] {
new SubscriberMethodInfo("onStickyEvent", EventBusManager.StickEvent.class, ThreadMode.MAIN, 0, true),
}));
}
private static voidputIndex(SubscriberInfo info) {
SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
}
@Override
publicSubscriberInfo getSubscriberInfo(Class subscriberClass) {
SubscriberInfo info =SUBSCRIBER_INDEX.get(subscriberClass);
if(info !=null) {
returninfo;
}else{
return null;
}
}
}
总结一句话：如果项目中通过反射可以获取的对应关系，可以通过获取编译时注解的方式进行索引加速
2.池化技术
EventBus的设计非常精致，但是有一个明显的缺陷：产生很多中间对象。为了最大限度地减少影响，项目中多处使用缓存，对象池。
METHOD_CACHE缓存订阅者类型与回调方法的列表，避免重复查找
classSubscriberMethodFinder {
List findSubscriberMethods(Class subscriberClass) {
List subscriberMethods =METHOD_CACHE.get(subscriberClass);
if(subscriberMethods !=null) {
returnsubscriberMethods;
}
if(ignoreGeneratedIndex) {
subscriberMethods = findUsingReflection(subscriberClass);
}else{
subscriberMethods = findUsingInfo(subscriberClass);
}
if(subscriberMethods.isEmpty()) {
throw newEventBusException("Subscriber "+ subscriberClass
+" and its super classes have no public methods with the @Subscribe annotation");
}else{
METHOD_CACHE.put(subscriberClass, subscriberMethods);
returnsubscriberMethods;
}
}
}
private static finalMap, List>METHOD_CACHE=newConcurrentHashMap<>();
eventTypesCache缓存事件类型与（事件类型父类和接口）的关系
private static finalMap, List>>eventTypesCache=newHashMap<>();
/** Looks up all Class objects including super classes and interfaces. Should also work for interfaces. */
private staticList> lookupAllEventTypes(Class eventClass) {
synchronized(eventTypesCache) {
List> eventTypes =eventTypesCache.get(eventClass);
if(eventTypes ==null) {
eventTypes =newArrayList<>();
Class clazz = eventClass;
while(clazz !=null) {
eventTypes.add(clazz);
addInterfaces(eventTypes, clazz.getInterfaces());
clazz = clazz.getSuperclass();
}
eventTypesCache.put(eventClass, eventTypes);
}
returneventTypes;
}
}
通过反射查找订阅方法时，将所有中间对象封装成FindState.全局维护一个FindState的对象池。使用完对象之后通过recycle()擦除痕迹。
classSubscriberMethodFinder {
privateList findUsingInfo(Class subscriberClass) {
FindState findState = prepareFindState();
findState.initForSubscriber(subscriberClass);
while(findState.clazz!=null) {
findState.subscriberInfo= getSubscriberInfo(findState);
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{
findUsingReflectionInSingleClass(findState);
}
findState.moveToSuperclass();
}
returngetMethodsAndRelease(findState);
}
private static finalFindState[]FIND_STATE_POOL=newFindState[POOL_SIZE];
privateList getMethodsAndRelease(FindState findState) {
List subscriberMethods =newArrayList<>(findState.subscriberMethods);
findState.recycle();
synchronized(FIND_STATE_POOL) {
for(inti =0; i
if(FIND_STATE_POOL[i] ==null) {
FIND_STATE_POOL[i] = findState;
break;
}
}
}
returnsubscriberMethods;
}
privateFindState prepareFindState() {
synchronized(FIND_STATE_POOL) {
for(inti = 0; i
FindState state =FIND_STATE_POOL[i];
if(state !=null) {
FIND_STATE_POOL[i] =null;
returnstate;
}
}
}
return newFindState();
}
static classFindState{
final List subscriberMethods = new ArrayList<>();
finalMapanyMethodByEventType=newHashMap<>();
finalMapsubscriberClassByMethodKey=newHashMap<>();
finalStringBuildermethodKeyBuilder=newStringBuilder(128);
ClasssubscriberClass;
Classclazz;
booleanskipSuperClasses;
SubscriberInfosubscriberInfo;
voidinitForSubscriber(Class subscriberClass) {
this.subscriberClass=clazz= subscriberClass;
skipSuperClasses=false;
subscriberInfo=null;
}
void recycle() {
subscriberMethods.clear();
anyMethodByEventType.clear();
subscriberClassByMethodKey.clear();
methodKeyBuilder.setLength(0);
subscriberClass = null;
clazz = null;
skipSuperClasses = false;
subscriberInfo = null;
}
}
回调方法队列PendPostQueue中的元素PendingPost本身就是对象池。构造器为私有，从而只能通过obtainPendingPost从对象池获取对象，对象池中有保存的对象则获取对象（ArrayList尾部获取），没有就通过new创建。releasePendingPost则将使用后的对象归还给对象池，归还的时候要将对象的使用痕迹擦除，同时要限制对象池大小为10000，防止对象池无限增大。
final classPendingPost {
private final static ListpendingPostPool= new ArrayList();
Objectevent;
Subscriptionsubscription;
PendingPostnext;
privatePendingPost(Object event, Subscription subscription) {
this.event= event;
this.subscription= subscription;
}
staticPendingPost obtainPendingPost(Subscription subscription, Object event) {
synchronized(pendingPostPool) {
intsize =pendingPostPool.size();
if(size >0) {
PendingPost pendingPost =pendingPostPool.remove(size -1);
pendingPost.event= event;
pendingPost.subscription= subscription;
pendingPost.next=null;
returnpendingPost;
}
}
return newPendingPost(event, subscription);
}
static void releasePendingPost(PendingPost pendingPost) {
pendingPost.event = null;
pendingPost.subscription = null;
pendingPost.next = null;
synchronized (pendingPostPool) {
// Don't let the pool grow indefinitely
if (pendingPostPool.size() < 10000) {
pendingPostPool.add(pendingPost);
}
}
}
}
总结一句话:通过编译时注解解决反射问题，缓存与对象池解决内存开销问题。
EventBus是通过可配置的门面来维护事件，订阅者与回调方法之间的关系。然后按照指定线程模型调度执行。的使用简洁，线程安全，高性能的消息总线。最重要的是，它带给大家一些编程上面的思考。
