EventBus和RxBus的使用

EventBus介绍：

Rx：函数响应式编程，EventBus：事件总线 。
EventBus 功能类似handler，通过一个类来发送post()信息，具体使用方法如下：

• 发送：

   EventBus.getDefault().post(new EventBussBean("demo执行了"));
  

• 两种接收方式：

  EventBus注册 ：EventBus.getDefault().register(this);  
  EventBus反注册：EventBus.getDefault().unregister(this);  
  

1. 用自带的方法接收，有4个方法：

   • onEvent:如果使用onEvent作为订阅函数，那么该事件在哪个线程发布出来的，onEvent就会在这个线程中运行，也就是说发布事件和接收事件线程在同一个线程。使用这个方法时，在onEvent方法中不能执行耗时操作，如果执行耗时操作容易导致事件分发延迟。
   • onEventMainThread:如果使用onEventMainThread作为订阅函数，那么不论事件是在哪个线程中发布出来的，onEventMainThread都会在UI线程中执行，接收事件就会在UI线程中运行，这个在Android中是非常有用的，因为在android中只能在UI线程中跟新UI，所以在onEvnetMainThread方法中是不能执行耗时操作的。
   • onEventBackground:如果使用onEventBackgrond作为订阅函数，那么如果事件是在UI线程中发布出来的，那么onEventBackground就会在子线程中运行，如果事件本来就是子线程中发布出来的，那么onEventBackground函数直接在该子线程中执行。
   • onEventAsync：使用这个函数作为订阅函数，那么无论事件在哪个线程发布，都会创建新的子线程在执行onEventAsync.

   注意： Activity中当有多个onEvent（或其他3个）时，参数的不同则是区分的关键：

   public void onEventMainThread(FirstEvent event) {  
   
   Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
    }  
   
   public void onEventMainThread(SecondEvent event) {  //消息会根据接收类的不同，自动区分调用
   
       Log.d("harvic", "onEventMainThread收到了消息：" + event.getMsg());  
   } 
   

2. 自定义接收方法：

   * 先在onCreate中注册： EventBus.getDefault().register(this);
   * 然后自定义接收方法：
    @Subscribe(sticky = true,threadMode = ThreadMode.POSTING) //粘性sticky作用：能接收到注册前的消息，发送时也需用postSticky();
       public void getMessage (EventBussBean evn) {
           evn.execute1();
           }  
   * 最后反注册：EventBus.getDefault().unregister(this); 
   

.

RxBus介绍：

EventBus采用事件总线，RxBus采用函数响应式编程方式实现，二者用谁做事件传递均可；

RxJava提供给开发者5种Subject：

PublishSubject：只会给把订阅的时间点之后的数据发送给观察者。
BehaviorSubject：在订阅者订阅时，会发送其最近发送的数据（如果此时还没有收到任何数据，它会发送一个默认值）。
ReplaySubject：在订阅者订阅时，会发送所有的数据给订阅者，无论它们是何时订阅的。
AsyncSubject：只在原Observable事件序列完成后，发送最后一个数据，后续若还有订阅者继续订阅该Subject, 则可以直接接收到最后一个值
SerializedSubject：待定；

RxBus是自己定义出来的，可用于替代handler和EventBus，主要用来处理应用程序间各个组件的通信，或者组件与组建之间的数据传递，不用再像BroadcastReceiver一样，把数据封装到intent里面再传递出去了。RxBus学的是一种思路，RxBus其实就是对Subject（Observable和Observer的子类）的功能的封装（ class Subject extends Observable implements Observer {}）。

• RxBus自定义：

 public class RxBus {
       private static volatile RxBus mDefaultInstance;
       private final Subject mBus;
       private final Map, Object> mStickyEventMap;

       public RxBus() {
          mBus = new SerializedSubject<>(PublishSubject.create());
          mStickyEventMap = new ConcurrentHashMap<>();
       }

      public static RxBus getDefault() {
         if (mDefaultInstance == null) {
           synchronized (RxBus.class) {
               if (mDefaultInstance == null) {
                   mDefaultInstance = new RxBus();
               }
           }
       }
       return mDefaultInstance;
     }

   /**
    * 发送事件
    */
    public void post(Object event) {
       mBus.onNext(event);
    }

   /**
    * 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
    */
     public  Observable toObservable(Class eventType) {
       return mBus.ofType(eventType);
     }

   /**
    * 判断是否有订阅者
    */
    public boolean hasObservers() {
       return mBus.hasObservers();
    }

    public void reset() {
       mDefaultInstance = null;
   }

    /**
    * Stciky 相关
    */

   /**
    * 发送一个新Sticky事件
    */
    public void postSticky(Object event) {
       synchronized (mStickyEventMap) {
           mStickyEventMap.put(event.getClass(), event);
       }
       post(event);
   }

    /**
    * 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
    */
     public  Observable toObservableSticky(final Class eventType) {
       synchronized (mStickyEventMap) {
           Observable observable = mBus.ofType(eventType);
           final Object event = mStickyEventMap.get(eventType);

           if (event != null) {
                return observable.mergeWith(Observable.create(new Observable.OnSubscribe() {
                   @Override
                   public void call(Subscriber subscriber) {
                       subscriber.onNext(eventType.cast(event));
                   }
               }));
           } else {
               return observable;
           }
       }
   }

   /**
    * 根据eventType获取Sticky事件
    */
   public  T getStickyEvent(Class eventType) {
       synchronized (mStickyEventMap) {
           return eventType.cast(mStickyEventMap.get(eventType));
       }
   }

   /**
    * 移除指定eventType的Sticky事件
    */
   public  T removeStickyEvent(Class eventType) {
       synchronized (mStickyEventMap) {
           return eventType.cast(mStickyEventMap.remove(eventType));
       }
   }

   /**
    * 移除所有的Sticky事件
    */
    public void removeAllStickyEvents() {
       synchronized (mStickyEventMap) {
           mStickyEventMap.clear();
       }
   }
}

• RxBus使用举例

   /*
   * 发送端：
   * 可以替换成String类型post(new BaseBean ())；接收处toObservableSticky(String.class)
   */
   RxBus.getDefault().post(new BaseBean ()); 

  /*
   * 接收端：
   */
   RxBus.getDefault().toObservableSticky(BaseBean.class)
       //在io线程进行订阅，可以执行一些耗时操作
       .subscribeOn(Schedulers.io())
       //在主线程进行观察，可做UI更新操作
       .unsubscribeOn(Schedulers.io())
       .observeOn(AndroidSchedulers.mainThread())
       //观察的对象
       .subscribe(user->{
         //获取到了一个对象，user  
         Toast.makeText(this,user.getUsername(),Toast.LENGTH_SHORT).show();
       });

注意：Subscription、Observer都是接口，Subscriber是抽象类，Observable是普通类；

.