Otto源码及Demo

/* * Copyright (C) 2012 Square, Inc. * Copyright (C) 2007 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.squareup.otto; import java.lang.reflect.InvocationTargetException; import java.util.Collection; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.CopyOnWriteArraySet; /** * Dispatches events to listeners, and provides ways for listeners to register themselves. * <p> * <p>The Bus allows publish-subscribe-style communication between components without requiring the components to * explicitly register with one another (and thus be aware of each other). It is designed exclusively to replace * traditional Android in-process event distribution using explicit registration or listeners. It is <em>not</em> a * general-purpose publish-subscribe system, nor is it intended for interprocess communication. * <p> * <h2>Receiving Events</h2> * To receive events, an object should: * <ol> * <li>Expose a public method, known as the <i>event handler</i>, which accepts a single argument of the type of event * desired;</li> * <li>Mark it with a {@link com.squareup.otto.Subscribe} annotation;</li> * <li>Pass itself to an Bus instance's {@link #register(Object)} method. * </li> * </ol> * <p> * <h2>Posting Events</h2> * To post an event, simply provide the event object to the {@link #post(Object)} method. The Bus instance will * determine the type of event and route it to all registered listeners. * <p> * <p>Events are routed based on their type &mdash; an event will be delivered to any handler for any type to which the * event is <em>assignable.</em> This includes implemented interfaces, all superclasses, and all interfaces implemented * by superclasses. * <p> * <p>When {@code post} is called, all registered handlers for an event are run in sequence, so handlers should be * reasonably quick. If an event may trigger an extended process (such as a database load), spawn a thread or queue it * for later. * <p> * <h2>Handler Methods</h2> * Event handler methods must accept only one argument: the event. * <p> * <p>Handlers should not, in general, throw. If they do, the Bus will wrap the exception and * re-throw it. * <p> * <p>The Bus by default enforces that all interactions occur on the main thread. You can provide an alternate * enforcement by passing a {@link ThreadEnforcer} to the constructor. * <p> * <h2>Producer Methods</h2> * Producer methods should accept no arguments and return their event type. When a subscriber is registered for a type * that a producer is also already registered for, the subscriber will be called with the return value from the * producer. * <p> * <h2>Dead Events</h2> * If an event is posted, but no registered handlers can accept it, it is considered "dead." To give the system a * second chance to handle dead events, they are wrapped in an instance of {@link com.squareup.otto.DeadEvent} and * reposted. * <p> * <p>This class is safe for concurrent use. * * @author Cliff Biffle * @author Jake Wharton */ public class Bus { public static final String DEFAULT_IDENTIFIER = "default"; /** * 订阅方法集合：ConcurrentMap<事件类型, 该事件的订阅方法集合> */ private final ConcurrentMap<Class<?>, Set<EventHandler>> handlersByType = new ConcurrentHashMap<Class<?>, Set<EventHandler>>(); /** * 生成事件的方法集合:ConcurrentMap<事件类型, 该事件生成方法> * * @Note Produce注解生成的事件方法，一个事件只能定义一个方法，不能重复定义。否则会抛出异常 * 原因参见AnnotatedHandlerFinder类中loadAnnotatedMethods 会检查是否已有该事件的@Produce方法。 */ private final ConcurrentMap<Class<?>, EventProducer> producersByType = new ConcurrentHashMap<Class<?>, EventProducer>(); /** * Identifier used to differentiate the event bus instance. */ private final String identifier; //当前Bus实例的名称 /** * Thread enforcer for register, unregister, and posting events. */ private final ThreadEnforcer enforcer;//线程检查，默认ThreadEnforcer.MAIN /** * 负责从类中查找@Suscribe和@Produce的方法 */ private final HandlerFinder handlerFinder; //默认为 HandlerFinder.ANNOTATED /** * 当前线程发送的事件队列 */ private final ThreadLocal<ConcurrentLinkedQueue<EventWithHandler>> eventsToDispatch = new ThreadLocal<ConcurrentLinkedQueue<EventWithHandler>>() { @Override protected ConcurrentLinkedQueue<EventWithHandler> initialValue() { return new ConcurrentLinkedQueue<EventWithHandler>(); } }; /** * 当前线程是否正在发送事件 */ private final ThreadLocal<Boolean> isDispatching = new ThreadLocal<Boolean>() { @Override protected Boolean initialValue() { return false; } }; /** * Creates a new Bus named "default" that enforces actions on the main thread. */ public Bus() { this(DEFAULT_IDENTIFIER); } public Bus(String identifier) { this(ThreadEnforcer.MAIN, identifier); } public Bus(ThreadEnforcer enforcer) { this(enforcer, DEFAULT_IDENTIFIER); } public Bus(ThreadEnforcer enforcer, String identifier) { this(enforcer, identifier, HandlerFinder.ANNOTATED); } Bus(ThreadEnforcer enforcer, String identifier, HandlerFinder handlerFinder) { this.enforcer = enforcer; this.identifier = identifier; this.handlerFinder = handlerFinder; } @Override public String toString() { return "[Bus \"" + identifier + "\"]"; } /** * 注册事件 * 查找类中所有的@Subscribe和@Produce方法 * 1）如果当前类中存在@Produce方法，则检查是否订阅了该事件类型的订阅方法，存在则生成事件对象并发送事件。 * 2）对于订阅方法，检查这些订阅方法的事件类型是否存在@Produce，存在的话，则调用Producer生成事件对象发送事件。 */ 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()) { 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 + "