AndroidKnife/RxBus详细说明

RxBus详细介绍

• RxBus类

  public class RxBus {
  
  /**
   * Instance of {@link Bus}
   */
  private static Bus sBus;
  
  /**R
   * Get the instance of {@link Bus}
   *
   * @return
   */
  public static synchronized Bus get() {
      if (sBus == null) {
          sBus = new Bus(ThreadEnforcer.ANY);
      }
      return sBus;
  }
  }

  • 从代码可以看到RxBus一个单例，是对Bus的封装

• Bus类

  • 这个类是核心，我们用的register,post等方法均有此类提供

  public class Bus {
  //构造方法
    Bus(ThreadEnforcer enforcer, String identifier, Finder finder){
      this.enforcer = enforcer;
      this.identifier = identifier;
      this.finder = finder;
  }
  
  //注册
  //1.查找注册类中的接收方法（被Suscribe注解的方法）,并保存到subscribersByType， 如果有已经发出的可接受事件，就接收
  //2.查找注册类中的发送方法（被Produce注解的方法），并保存到producersByType，如果有已经注册的接收方法，就发送
  public void register(Object object) {
      enforcer.enforce(this);
  }
  
  //解注册
  //从producersByType和subscribersByType移除数据
  public void unregister(Object object) {
      enforcer.enforce(this);
  }
  
  //post
  //使类及父类放在同一个容器,把类和父类分别发送(类B继承A ，post一个A时，所有接收A和B的地方，都能接收到)
  //发送数据
  //没有接收event的地方,就把event封装为DeadEvent,发送出去
  public void post(String tag, Object event) {
      enforcer.enforce(this);
  }
  
  //分发事件
  protected void dispatch(Object event, SubscriberEvent wrapper) {
      if (wrapper.isValid()) {
          wrapper.handle(event);
      }
  }
  }

  • 构造方法

    • ThreadEnforcer:一个接口，用于监视一个特定的Bus是否执行在指定的线程,从上面Bus的方法可以到，每一个主要的方法中都会先调用enforcer.enforce()方法
      

      public interface ThreadEnforcer {
      void enforce(Bus bus);
      
      ThreadEnforcer ANY = new ThreadEnforcer() {
          @Override
          public void enforce(Bus bus) {
              // Allow any 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());
              }
          }
      };
      }

  • identifier: 一个标示，用于区分不同的Bus实例,默认为“default”

  • finder:一个接口，两个方法

    /**
    *找到注册类的producer方法（被@Produce注解的方法）
    *listener 注册的类
    */
    Map<EventType, ProducerEvent> findAllProducers(Object listener);
    
    /**
    *找到注册类的subscriber方法（被@Subscriber注解的方法）
    *listener 注册的类
    */
    Map<EventType, Set<SubscriberEvent>> findAllSubscribers(Object listener);
    
    //默认提供的接口实现
    Finder ANNOTATED = new Finder() {
        @Override
        public Map<EventType, ProducerEvent> findAllProducers(Object listener) {
            return AnnotatedFinder.findAllProducers(listener);
        }
    
        @Override
        public Map<EventType, Set<SubscriberEvent>> findAllSubscribers(Object listener) {
            return AnnotatedFinder.findAllSubscribers(listener);
        }
    };

• Produce:注释,用于注释一个可发送的方法（粘性发送用）
• Subscribe:注释，用于注释一个接收方法

• Tag:注释,一个标识

• AnnotatedFinder

  • 一个常量类，其中具体实现查找被subscriber和producer注解的方法
    

    //找到所有被Produce注解的方法,并返回一个Map (listener注册的类对象)
    static Map<EventType, ProducerEvent> findAllProducers(Object listener) {}
    
    //找到所有被Subscribe注解的方法,并返回一个Map
    static Map<EventType, Set<SubscriberEvent>> findAllSubscribers(Object listener) {}
    
    //具体实现方法
    private static void loadAnnotatedMethods(Class<?> listenerClass,
                                             Map<EventType, SourceMethod> producerMethods, Map<EventType, Set<SourceMethod>> subscriberMethods) {}

• EventType

  • 被注解方法的标志, 用于区别被注解的方法
  • 在查找被注解方法时,结果回存放在Map中,此类作为结果Map的key值
    

    /**
    * 被注解方法的标志,  用于区别被注解的方法
    * 在查找被注解方法时,结果回存放在Map中,此类作为结果Map的key值
    */
    public class EventType {
    /**
     * Event Tag
     */
    private final String tag;  //方法注解中的tag  eg.@Subscribe (tags = {@Tag(Contants.TAG_MSG_DEFAULT)}) 中的tag   @Produce (tags = {@Tag(Contants.TAG_MSG_DEFAULT)}) 中的tag
    
    /**
     * Event Clazz
     */
    private final Class<?> clazz;  // eg. @Subscribe 注解方法中的参数 @Produce 注解方法中的参数
    }

• ProducerEvent

  • 被@Produce注解的方法，会生成一个此类的实例对象,有三个主要参数target，method，thread
  • target:注册类(eg. 类A中有Produce注释的方法, target就指的类A)
  • method:被Produce注释的方法
  • thread:被Produce注释的方法声明的线程

  • produce():创建一个Observable对象,并指定订阅线程为thread

       public Observable produce() {
        return Observable.create(new Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber<? super Object> subscriber) {
                try {
                    subscriber.onNext(produceEvent());
                    subscriber.onCompleted();
                } catch (InvocationTargetException e) {
                    throwRuntimeException("Producer " + ProducerEvent.this + " threw an exception.", e);
                }
            }
        }).subscribeOn(EventThread.getScheduler(thread));
    }

  • produceEvent():执行target中的method方法

    private Object produceEvent() throws InvocationTargetException {
    if (!valid) {
        throw new IllegalStateException(toString() + " has been invalidated and can no longer produce events.");
    }
    try {
        //调用target中的方法
        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;
    }
    }

• SubscriberEvent

  • 被@Subscribe注解的方法，会生成一个此类的实例对象,有三个主要参数target，method，thread
  • target:注册类(eg. 类A中有Subscribe注释的方法, target就指的类A)
  • method:被Subscribe注释的方法
  • thread:被Subscribe注释的方法声明的线程

  • handle() :发送事件,此方法中的subject是被观察者

    //event:接收到的结果
    //subject
    public void handle(Object event) {
    subject.onNext(event);
    }

  • initObservable():初始化subject

    private void initObservable() {
    subject = PublishSubject.create();
    subject.onBackpressureBuffer().observeOn(EventThread.getScheduler(thread))
            .subscribe(new Action1<Object>() {
                @Override
                public void call(Object event) {
                    try {
                        if (valid) {
                            handleEvent(event);
                        }
                    } catch (InvocationTargetException e) {
                        throwRuntimeException("Could not dispatch event: " + event.getClass() + " to subscriber " + SubscriberEvent.this, e);
                    }
                }
            });
    }

  • handleEvent():执行method方法

    protected void handleEvent(Object event) throws InvocationTargetException {
    method.invoke(target, event);
    }