Otto的使用和源码分析

Otto

Otto是square的一个event bus实现。

Event bus是一款针对Android优化的发布/订阅事件总线，主要功能是替代Intent、Handler、BroadCast

在Activity、Fragment、Service、Thread之间传递消息。其优点是开销小，代码更优雅，以及

将发送者和接收者解耦。

下载

在Android studio的module级别的build.gradle中dependencies下加入

compile 'com.squareup:otto:1.3.8'

使用

1.新建一个Bus实例，建议使用单例。

java

Bus bus = new Bus();

2.事件发布是非常重要的，因为它可以通知相应事件的订阅者某个动作已经发生。任何的类实例都可以

通过Bus发布事件，并且只有订阅了该事件的订阅者才会收到相应通知。

通过post方法发布一个新的事件

java

bus.post(new AnswerAvailableEvent(42));

除此之外，还有另外一种方法可以发布事件，这种形式会在Bus调用register方法时立即发布事件。

java

@Produce

public AnswerAvailableEvent produceAnswer() {

// Assuming 'lastAnswer' exists.

return new AnswerAvailableEvent(this.lastAnswer);

}

在方法级别上添加@Produce注解，方法的访问权限一定得是public的，并且其返回值类型是所发布

的事件类型。

这种事件发布形式还必需得在类实例中注册Bus实例

java

bus.register(this);

否则这个事件是无法让其订阅者接收到事件通知的。

3.订阅一个事件，你需要在方法级别上添加一个@Subscribe的注解。这个方法只能带有一个参数，

并且类型是你需要的订阅事件类型。

订阅一个事件，需要这样做

java

@Subscribe

public void answerAvailable(AnswerAvailableEvent event) {

// TODO: React to the event somehow!

}

需要注意的是，上面的方法其访问权限一定得是public的，其他无限制。

为了能够接收到事件，类实例需要注册Bus。通过下面方式注册

java

bus.register(this);

我们可以在适当的时候调用unregister方法取消Bus的注册

java

bus.unregister(this);

我们可以在Activity和Fragment的OnResume方法中注册Bus，然后在OnPause方法中取消注册。

4.默认的，新建的Bus是在主线程上活动的。

java

Bus bus1 = new Bus();

Bus bus2 = new Bus(ThreadEnforcer.MAIN);

上面两句代码是等价的。

你还可以实例化一个在任何线程都可以活动的Bus，

java

Bus bus3 = new Bus(ThreadEnforcer.ANY);

5.对于上面的使用方法，我是参照官方文档做一个大概的说明。大家可以使用git clone下官方提供

的sample研究具体的使用方法。

链接： https://github.com/square/otto

源码分析

Otto的源码只有九个类，阅读起来还是很容易理解的。

先看@Produce、@Subscribe这两个注解的定义。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Produce {

}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Subscribe {

}

可以看出这两个注解都是在jvm运行时可获得的，并且都是作用在方法级别上。

再来看ThreadEnforcer、HandlerFinder两个接口。

public interface ThreadEnforcer {

/**
* 强制bus在某个确定的线程
*/
void enforce(Bus bus);

/** A {@link ThreadEnforcer} that does no verification. */
ThreadEnforcer ANY = new ThreadEnforcer() {
@Override public void enforce(Bus bus) {
// Allow any thread.
}
};

/** A {@link ThreadEnforcer} that confines {@link Bus} methods to the main thread. */
ThreadEnforcer MAIN = new ThreadEnforcer() {
@Override public void enforce(Bus bus) {
if (Looper.myLooper() != Looper.getMainLooper()) {
throw new IllegalStateException("Event bus " + bus +
" accessed from non-main thread " + Looper.myLooper());
}
}
};

}

ThreadEnforcer里面提供了两个默认的实现，其中我们新创建的Bus实例是默认使用Android的主线程的。

/** Finds producer and subscriber methods. */
interface HandlerFinder {

Map<Class<?>, EventProducer> findAllProducers(Object listener);

Map<Class<?>, Set<EventHandler>> findAllSubscribers(Object listener);

HandlerFinder ANNOTATED = new HandlerFinder() {
@Override
public Map<Class<?>, EventProducer> findAllProducers(Object listener) {
return AnnotatedHandlerFinder.findAllProducers(listener);
}

@Override
public Map<Class<?>, Set<EventHandler>> findAllSubscribers(Object listener) {
return AnnotatedHandlerFinder.findAllSubscribers(listener);
}
};
}

HandlerFinder是用于查找使用了@Produce和@Subscribe的方法及事件类型的的。从方法定义就可以看出，一个

类中只能存在一个通过@Produce发布事件的方法，却可以存在多个使用@Subscribe的方法，即事件订阅者。

同样的，HandlerFinder里面也提供了一个默认的实现，委派AnnotatedHandlerFinder进行具体的操作。

其中，EventProducer的代码实现如下

class EventProducer {

/** Object sporting the producer method. */
final Object target;
/** Producer method. */
private final Method method;

EventProducer(Object target, Method method) {
if (target == null) {
throw new NullPointerException("EventProducer target cannot be null.");
}
if (method == null) {
throw new NullPointerException("EventProducer method cannot be null.");
}

this.target = target;
this.method = method;

/** 抑制java对修饰符访问权限的检查，提高jdk的反射效率 */
method.setAccessible(true);

...
}

/**
* 通过反射调用方法
*/
public Object produceEvent() throws InvocationTargetException {
if (!valid) {
throw new IllegalStateException(toString() + " has been invalidated and can no longer produce events.");
}
try {
return method.invoke(target);
} catch (IllegalAccessException e) {
throw new AssertionError(e);
} catch (InvocationTargetException e) {
if (e.getCause() instanceof Error) {
throw (Error) e.getCause();
}
throw e;
}
}

// 重写toString()、hashCode()、equals()方法
}

EventHandler类的代码也差不多。

再来看看AnnotatedHandlerFinder到底干了哪些事。

final class AnnotatedHandlerFinder {

/*
* 用于保存使用了@Produce注解的类及方法，其中map的键是监听类，值是一个map，值的map的
* 键是事件类型，值是方法
*/
private static final ConcurrentMap<Class<?>, Map<Class<?>, Method>> PRODUCERS_CACHE =
new ConcurrentHashMap<Class<?>, Map<Class<?>, Method>>();

/** 用于保存使用了@Subscribe注解的类及方法 */
private static final ConcurrentMap<Class<?>, Map<Class<?>, Set<Method>>> SUBSCRIBERS_CACHE =
new ConcurrentHashMap<Class<?>, Map<Class<?>, Set<Method>>>();

/** 加载使用了@Produce注解的类及方法 */
private static void loadAnnotatedProducerMethods(Class<?> listenerClass,
Map<Class<?>, Method> producerMethods) {
Map<Class<?>, Set<Method>> subscriberMethods = new HashMap<Class<?>, Set<Method>>();
loadAnnotatedMethods(listenerClass, producerMethods, subscriberMethods);
}

/** 加载使用了@Subscribe注解的类及方法 */
private static void loadAnnotatedSubscriberMethods(Class<?> listenerClass,
Map<Class<?>, Set<Method>> subscriberMethods) {
Map<Class<?>, Method> producerMethods = new HashMap<Class<?>, Method>();
loadAnnotatedMethods(listenerClass, producerMethods, subscriberMethods);
}

/**
* 加载所有使用了@Produce和@Subscribe注解的方法
*/
private static void loadAnnotatedMethods(Class<?> listenerClass,
Map<Class<?>, Method> producerMethods, Map<Class<?>, Set<Method>> subscriberMethods) {
for (Method method : listenerClass.getDeclaredMethods()) {
// The compiler sometimes creates synthetic bridge methods as part of the
// type erasure process. As of JDK8 these methods now include the same
// annotations as the original declarations. They should be ignored for
// subscribe/produce.
if (method.isBridge()) {
continue;
}
if (method.isAnnotationPresent(Subscribe.class)) {
Class<?>[] parameterTypes = method.getParameterTypes();

/** 参数个数判断 */
if (parameterTypes.length != 1) {
throw new IllegalArgumentException("Method " + method + " has @Subscribe annotation but requires "
+ parameterTypes.length + " arguments.  Methods must require a single argument.");
}

Class<?> eventType = parameterTypes[0];

/** 判断是否为接口 */
if (eventType.isInterface()) {
throw new IllegalArgumentException("Method " + method + " has @Subscribe annotation on " + eventType
+ " which is an interface.  Subscription must be on a concrete class type.");
}

/** 判断方法的访问权限是否为public */
if ((method.getModifiers() & Modifier.PUBLIC) == 0) {
throw new IllegalArgumentException("Method " + method + " has @Subscribe annotation on " + eventType
+ " but is not 'public'.");
}

Set<Method> methods = subscriberMethods.get(eventType);
if (methods == null) {
methods = new HashSet<Method>();
subscriberMethods.put(eventType, methods);
}
methods.add(method);
} else if (method.isAnnotationPresent(Produce.class)) {
Class<?>[] parameterTypes = method.getParameterTypes();

/** 参数个数判断 */
if (parameterTypes.length != 0) {
throw new IllegalArgumentException("Method " + method + "has @Produce annotation but requires "
+ parameterTypes.length + " arguments.  Methods must require zero arguments.");
}

/** 方法返回类型是否为Void.class判断 */
if (method.getReturnType() == Void.class) {
throw new IllegalArgumentException("Method " + method
+ " has a return type of void.  Must declare a non-void type.");
}

Class<?> eventType = method.getReturnType();

/** 是否为接口判断 */
if (eventType.isInterface()) {
throw new IllegalArgumentException("Method " + method + " has @Produce annotation on " + eventType
+ " which is an interface.  Producers must return a concrete class type.");
}

/** 方法返回值判断 */
if (eventType.equals(Void.TYPE)) {
throw new IllegalArgumentException("Method " + method + " has @Produce annotation but has no return type.");
}

/** 判断方法的访问权限是否为public */
if ((method.getModifiers() & Modifier.PUBLIC) == 0) {
throw new IllegalArgumentException("Method " + method + " has @Produce annotation on " + eventType
+ " but is not 'public'.");
}

/** 判断此类事件是否已经由@Produce发布过 */
if (producerMethods.containsKey(eventType)) {
throw new IllegalArgumentException("Producer for type " + eventType + " has already been registered.");
}
producerMethods.put(eventType, method);
}
}

/** 把查找到的分别放进缓存 */
PRODUCERS_CACHE.put(listenerClass, producerMethods);
SUBSCRIBERS_CACHE.put(listenerClass, subscriberMethods);
}

/** 查找所有的@Produce */
static Map<Class<?>, EventProducer> findAllProducers(Object listener) {
final Class<?> listenerClass = listener.getClass();
Map<Class<?>, EventProducer> handlersInMethod = new HashMap<Class<?>, EventProducer>();

Map<Class<?>, Method> methods = PRODUCERS_CACHE.get(listenerClass);
/** 如果缓存中不存在 */
if (null == methods) {
methods = new HashMap<Class<?>, Method>();
loadAnnotatedProducerMethods(listenerClass, methods);
}
if (!methods.isEmpty()) {
for (Map.Entry<Class<?>, Method> e : methods.entrySet()) {
/** 包装到EventProducer */
EventProducer producer = new EventProducer(listener, e.getValue());
handlersInMethod.put(e.getKey(), producer);
}
}

return handlersInMethod;
}

/** 查找所有的@Subscribe */
static Map<Class<?>, Set<EventHandler>> findAllSubscribers(Object listener) {
...
}

private AnnotatedHandlerFinder() {
// No instances.
}

}

阅读AnnotatedHandlerFinder之后，可以很清楚地知道它主要是负责查找指定类中带有@Produce

和@Subscribe注解的方法，并且把相应的事件类型放到相应的缓存中。

其中HandlerFinder的默认实现ANNOTATED就是使用了AnnotatedHandlerFinder.findAllProducers(listener)

和AnnotatedHandlerFinder.findAllSubscribers(listener)来完成具体的注解查找工作的。

最后只剩下最重要的Bus类了。

因为我们使用Otto是从在Activity或Fragment的OnResume方法中进行register()开始的，所有我们

看看register()到底干了什么事。

public void register(Object object) {
if (object == null) {
throw new NullPointerException("Object to register must not be null.");
}
/** 确认所在线程 */
enforcer.enforce(this);

/** 查找所有的@Produce */
Map<Class<?>, EventProducer> foundProducers = handlerFinder.findAllProducers(object);
for (Class<?> type : foundProducers.keySet()) {

/** 判断是否当前类已经存在一个使用@Produce的方法 */
final EventProducer producer = foundProducers.get(type);
EventProducer previousProducer = producersByType.putIfAbsent(type, producer);
//checking if the previous producer existed
if (previousProducer != null) {
throw new IllegalArgumentException("Producer method for type " + type
+ " found on type " + producer.target.getClass()
+ ", but already registered by type " + previousProducer.target.getClass() + ".");
}
Set<EventHandler> handlers = handlersByType.get(type);
if (handlers != null && !handlers.isEmpty()) {
for (EventHandler handler : handlers) {
/** 分发事件 */
dispatchProducerResultToHandler(handler, producer);
}
}
}

/** 查找所有的@Subscribe */
Map<Class<?>, Set<EventHandler>> foundHandlersMap = handlerFinder.findAllSubscribers(object);
for (Class<?> type : foundHandlersMap.keySet()) {
Set<EventHandler> handlers = handlersByType.get(type);
if (handlers == null) {
//concurrent put if absent
Set<EventHandler> handlersCreation = new CopyOnWriteArraySet<EventHandler>();
handlers = handlersByType.putIfAbsent(type, handlersCreation);
if (handlers == null) {
handlers = handlersCreation;
}
}
final Set<EventHandler> foundHandlers = foundHandlersMap.get(type);
if (!handlers.addAll(foundHandlers)) {
throw new IllegalArgumentException("Object already registered.");
}
}

for (Map.Entry<Class<?>, Set<EventHandler>> entry : foundHandlersMap.entrySet()) {
Class<?> type = entry.getKey();
EventProducer producer = producersByType.get(type);
if (producer != null && producer.isValid()) {
Set<EventHandler> foundHandlers = entry.getValue();
for (EventHandler foundHandler : foundHandlers) {
if (!producer.isValid()) {
break;
}
if (foundHandler.isValid()) {
/** 分发事件 */
dispatchProducerResultToHandler(foundHandler, producer);
}
}
}
}
}

到了这里，我们已经很清楚了，register方法主要是查找所有的@Produce和@Subscribe并且进行事件

分发给handler处理。

private void dispatchProducerResultToHandler(EventHandler handler, EventProducer producer) {
Object event = null;
try {
/** 通过反射调用方法，前面已经在EventProducer分析过，发布@Produce的事件 */
event = producer.produceEvent();
} catch (InvocationTargetException e) {
throwRuntimeException("Producer " + producer + " threw an exception.", e);
}
if (event == null) {
return;
}
/** 再次分发事件 */
dispatch(event, handler);
}

protected void dispatch(Object event, EventHandler wrapper) {
try {
/** 通过反射调用方法，前面已经在EventHandler分析过，这里就是接收到事件通知之后执行具体的操作，执行@Subscribe的方法 */
wrapper.handleEvent(event);
} catch (InvocationTargetException e) {
throwRuntimeException(
"Could not dispatch event: " + event.getClass() + " to handler " + wrapper, e);
}
}

至于unregister和register方法则是相反的操作，移除当前类及方法的监听。

当我们调用post发布事件又发生了什么事呢？

下面我们来看看post方法的实现。

public void post(Object event) {
if (event == null) {
throw new NullPointerException("Event to post must not be null.");
}
enforcer.enforce(this);

Set<Class<?>> dispatchTypes = flattenHierarchy(event.getClass());

boolean dispatched = false;
for (Class<?> eventType : dispatchTypes) {
Set<EventHandler> wrappers = getHandlersForEventType(eventType);

if (wrappers != null && !wrappers.isEmpty()) {
dispatched = true;
for (EventHandler wrapper : wrappers) {
/** 把事件添加进队列 */
enqueueEvent(event, wrapper);
}
}
}

/** 没有订阅者的事件没有被分发，被封装成DeadEvent再次post出去 */
if (!dispatched && !(event instanceof DeadEvent)) {
post(new DeadEvent(this, event));
}

/** 逐一分发事件队列的事件方法 */
dispatchQueuedEvents();
}

protected void enqueueEvent(Object event, EventHandler handler) {
eventsToDispatch.get().offer(new EventWithHandler(event, handler));
}

protected void dispatchQueuedEvents() {
// don't dispatch if we're already dispatching, that would allow reentrancy and out-of-order events. Instead, leave
// the events to be dispatched after the in-progress dispatch is complete.
if (isDispatching.get()) {
return;
}

isDispatching.set(true);
try {
while (true) {
EventWithHandler eventWithHandler = eventsToDispatch.get().poll();
if (eventWithHandler == null) {
break;
}

if (eventWithHandler.handler.isValid()) {
/** 上面这个方法已经列出分析过 */
dispatch(eventWithHandler.event, eventWithHandler.handler);
}
}
} finally {
isDispatching.set(false);
}
}

最后，整个Otto的源码分析过程就完成了。