首页 > 其他 > 详细

otto源码分析

时间：2015-08-28 13:39:26      阅读：288      评论：0      收藏：0      [点我收藏+]
otto这个开源项目是一个event bus模式的消息框架，用于程序各个模块之间的通信，此消息框架可以使得各个
模块之间减少耦合性。

此项目是支付公司square一个开源项目，项目托管于github
https://github.com/square/otto


基本模型是，Android的组件可以注册监听,然后发送消息，接收消息，模式就是观察者模式，但是有别于
java实现的观察者模式，otto更具解耦性，通过注解可以现实监听工作。

otto中的总控制中心的类是Bus，复杂事件的注册分发工作。

首先要把需要把监听事件的组件或者发送事件的组件注册进去
调用Bus的register方法
public void register(Object object) 

这个方法的解释是这样的，先看下英文

[html]  view plain copy
  1. /**  
  2.    * Registers all handler methods on {@code object} to receive events and producer methods to provide events.  
  3.    * If any subscribers are registering for types which already have a producer they will be called immediately  
  4.    * with the result of calling that producer.  
  5.    * If any producers are registering for types which already have subscribers, each subscriber will be called with  
  6.    * the value from the result of calling the producer.  
  7.    *  
  8.    * @param object object whose handler methods should be registered.  
  9.    * @throws NullPointerException if the object is null.  
  10.    */  

参数这个对象的所有的事件处理方法（订阅方法）用于处理接受到的事件，生产者方法用于提供事件。
意思是说，这个注册者即可以接收事件，也可以生产事件。
接着说了注册时的一些特殊情况，
（1）如果在注册的时候，订阅了一个事件类型，并且有产生事件的方法，那么会立即调用产生事件的方法，
把事件分发给这个订阅者方法。
（2）如果在注册的时候，产生特定事件的方法已经存在了订阅者，会调用事件产生方法，把事件分发给事件
订阅者。
方法的具体实现分析：

[java]  view plain copy 技术分享 技术分享
  1. public void register(Object object) {  
  2.     if (object == null) {  
  3.       throw new NullPointerException("Object to register must not be null.");  
  4.     }  
  5.     //检查是否在主线程中进行了注册的，默认必须在主线程中调用  
  6.     enforcer.enforce(this);  
  7.      
  8.     //key是事件的class对象  
  9.     Map<Class<?>, EventProducer> foundProducers = handlerFinder.findAllProducers(object);  

上面的代码用于获取这个被注册对象的所有生产者方法，可以对应于多个事件的生产者方法
           一个被注册对象，同一个事件只能注册一个生产者方法。
 
handlerFinder是HandlerFinder的实例，是Bus的辅助类，用于找到指定被注册者的所有生产者和订阅者方法。
handlerFinder .findAllProducers(object)返回一个map集合，key是事件的Class的实例，value
是EventProducer是对生产者方法和被注册者实例的包装。

从这里可以看出，虽然没有继续看这个方法的代码，可以猜测被注册者对于同一个事件只能有一个生产者。
我们继续跟踪HandlerFinder  findAllProducers（）方法的代码
HandlerFinder只是一个借口，然后在其内部实现了一个内部类
如下：

[java]  view plain copy 技术分享 技术分享
  1. HandlerFinder ANNOTATED = new HandlerFinder() {  
  2.     @Override  
  3.     public Map<Class<?>, EventProducer> findAllProducers(Object listener) {  
  4.       return AnnotatedHandlerFinder.findAllProducers(listener);  
  5.     }  
  6.   
  7.     @Override  
  8.     public Map<Class<?>, Set<EventHandler>> findAllSubscribers(Object listener) {  
  9.       return AnnotatedHandlerFinder.findAllSubscribers(listener);  
  10.     }  
  11.   };  

会调用到这句代码：
AnnotatedHandlerFinder.findAllProducers(listener)

进去看下代码

[java]  view plain copy 技术分享 技术分享
  1. static Map<Class<?>, EventProducer> findAllProducers(Object listener) {  
  2.     final Class<?> listenerClass = listener.getClass();  
  3.     Map<Class<?>, EventProducer> handlersInMethod = new HashMap<Class<?>, EventProducer>();  
  4.      //检查是否不存在此listenerClass的生产者方法，需要找出来放到PRODUCERS_CACHE中  
  5.      //PRODUCERS_CACHE是一个map，可以是listener的class对象，值是所有的事件生产者方法  
  6.     if (!PRODUCERS_CACHE.containsKey(listenerClass)) {  
  7.       loadAnnotatedMethods(listenerClass);  
  8.     }  
  9. //下面的代码就是把所有的生产者方法封装起来，返回给调用者  
  10.     Map<Class<?>, Method> methods = PRODUCERS_CACHE.get(listenerClass);  
  11.     if (!methods.isEmpty()) {  
  12.       for (Map.Entry<Class<?>, Method> e : methods.entrySet()) {  
  13.         EventProducer producer = new EventProducer(listener, e.getValue());  
  14.         handlersInMethod.put(e.getKey(), producer);  
  15.       }  
  16.     }  
  17.   
  18.     return handlersInMethod;  
  19.   }  

我们再回到Bus的register方法

[java]  view plain copy 技术分享 技术分享
  1. //key是事件的class对象  
  2.     Map<Class<?>, EventProducer> foundProducers = handlerFinder.findAllProducers(object);  
  3.     for (Class<?> type : foundProducers.keySet()) {  
  4.             
  5.      //下面几行代码用来检查，事件是否已经注册过了，一个类一个事件只能注册一次  
  6.       final EventProducer producer = foundProducers.get(type);  
  7.       EventProducer previousProducer = producersByType.putIfAbsent(type, producer);  
  8.       //checking if the previous producer existed  
  9.       if (previousProducer != null) {  
  10.         throw new IllegalArgumentException("Producer method for type " + type  
  11.           + " found on type " + producer.target.getClass()  
  12.           + ", but already registered by type " + previousProducer.target.getClass() + ".");  
  13.       }  
  14.       //检查一下注册这个事件的注册者是否存在，存在就回调一下注册者  
  15.       Set<EventHandler> handlers = handlersByType.get(type);  
  16.       if (handlers != null && !handlers.isEmpty()) {  
  17.         for (EventHandler handler : handlers) {  
  18.           dispatchProducerResultToHandler(handler, producer);  
  19.         }  
  20.       }  
  21.     }  
这行代码用于回调
dispatchProducerResultToHandler(handler, producer);
具体实现就是通过反射去调用producer生产出方事件，把事件传递给handler，再通过反射
回调注册的方法。

继续。。。

[java]  view plain copy 技术分享 技术分享
  1. //如果有处理此事件的注册者，回调注册者  
  2.     Map<Class<?>, Set<EventHandler>> foundHandlersMap = handlerFinder.findAllSubscribers(object);  
  3.     for (Class<?> type : foundHandlersMap.keySet()) {  
  4.     //type变量是事件的class对象  
  5.       Set<EventHandler> handlers = handlersByType.get(type);  
  6.       if (handlers == null) {  
  7.         //concurrent put if absent  
  8.         Set<EventHandler> handlersCreation = new CopyOnWriteArraySet<EventHandler>();  
  9.         handlers = handlersByType.putIfAbsent(type, handlersCreation);  
  10.         if (handlers == null) {  
  11.             handlers = handlersCreation;  
  12.         }  
  13.       }  
  14.       final Set<EventHandler> foundHandlers = foundHandlersMap.get(type);  
  15.       handlers.addAll(foundHandlers);  
  16.     }  

regeister这个方法解释完了。

在继续看下post（event）方法
这个方法的作用是分发事件到所有注册这个事件的方法
有可能这个事件分发失败，会封装一个DeadEvent对象，然后重新分发，但是这个DeadEvent对象没有被处理。。。

[java]  view plain copy 技术分享 技术分享
  1. public void post(Object event) {  
  2.     if (event == null) {  
  3.       throw new NullPointerException("Event to post must not be null.");  
  4.     }  
  5.     enforcer.enforce(this);  
  6.     //返回这个event的所有继承关系链的所有class对象（父类class对象和自己）  
  7.     Set<Class<?>> dispatchTypes = flattenHierarchy(event.getClass());  
  8.     //对event家族的所有类的相关注册方法进行调用  
  9.     boolean dispatched = false;  
  10.     for (Class<?> eventType : dispatchTypes) {  
  11.     //获得和eventType相关的所有注册方法  
  12.       Set<EventHandler> wrappers = getHandlersForEventType(eventType);  
  13.       //把需要回调处理的注册方法的包装类塞进当前线程处理的队列中去  
  14.       if (wrappers != null && !wrappers.isEmpty()) {  
  15.         dispatched = true;  
  16.         for (EventHandler wrapper : wrappers) {  
  17.           enqueueEvent(event, wrapper);  
  18.         }  
  19.       }  
  20.     }  
  21.     //没处理的，再分发一次，但是没有发现再次处理的逻辑  
  22.     if (!dispatched && !(event instanceof DeadEvent)) {  
  23.       post(new DeadEvent(this, event));  
  24.     }  
  25.   
  26.     dispatchQueuedEvents();  
  27.   }  

接下来就是注销方法unregister(listener)
删除和这个listener对象相关的生产事件的方法和注册监听的方法

[java]  view plain copy 技术分享 技术分享
  1. public void unregister(Object object) {  
  2.     if (object == null) {  
  3.       throw new NullPointerException("Object to unregister must not be null.");  
  4.     }  
  5.     enforcer.enforce(this);  
  6.   
  7.     Map<Class<?>, EventProducer> producersInListener = handlerFinder.findAllProducers(object);  
  8.     for (Map.Entry<Class<?>, EventProducer> entry : producersInListener.entrySet()) {  
  9.       final Class<?> key = entry.getKey();  
  10.       EventProducer producer = getProducerForEventType(key);  
  11.       EventProducer value = entry.getValue();  
  12.   
  13.       if (value == null || !value.equals(producer)) {  
  14.         throw new IllegalArgumentException(  
  15.             "Missing event producer for an annotated method. Is " + object.getClass()  
  16.                 + " registered?");  
  17.       }  
  18.       producersByType.remove(key).invalidate();  
  19.     }  
  20.     //返回当前对象的所有注册的方法，置为无效并删除掉  
  21.     Map<Class<?>, Set<EventHandler>> handlersInListener = handlerFinder.findAllSubscribers(object);  
  22.     for (Map.Entry<Class<?>, Set<EventHandler>> entry : handlersInListener.entrySet()) {  
  23.     //返回对应event的所有注册方法的包装类  
  24.       Set<EventHandler> currentHandlers = getHandlersForEventType(entry.getKey());  
  25.       Collection<EventHandler> eventMethodsInListener = entry.getValue();  
  26.   
  27.       if (currentHandlers == null || !currentHandlers.containsAll(eventMethodsInListener)) {  
  28.         throw new IllegalArgumentException(  
  29.             "Missing event handler for an annotated method. Is " + object.getClass()  
  30.                 + " registered?");  
  31.       }  
  32.   
  33.       for (EventHandler handler : currentHandlers) {  
  34.         if (eventMethodsInListener.contains(handler)) {  
  35.           handler.invalidate();  
  36.         }  
  37.       }  
  38.       currentHandlers.removeAll(eventMethodsInListener);  
  39.     }  
  40.   }  
最后总结一下，
(1)同一个事件只能有一个生产此事件的方法，如果存在多个会报非检查异常，产生此类事件的只允许有一个来源或者说只允许
有一个活者的来源。
(2)同一个事件可以有多个注册监听同一个事件的方法，只要存在就会分发给他们。
(3)按照官方的demo尽量只有一个Bus实例，一是减少内存消耗，也利于分发工作，如果不同的Bus，那么就无法把分发给其他Bus的注册监听的方法了。

这个EventBus消息框架比较适合推送的处理中心对消息的分发工作，可以解耦的方式，分发给程序的各个模块。

otto源码分析

原文：http://my.oschina.net/owen123456/blog/498608
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！