devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RxBus的封装_rxbus封装

作者：Cpp五条 | 2024-03-23 00:07:02

赞

踩

rxbus封装

要实现fragment与activity之前的通讯，或者service与activity的通讯，我们可以有好几种方式实现

1、广播

2、回调接口

3、eventBus、RxBus

4、其他

 

 

封装了一下RxBus的使用，废话不多说，直接上源码：

GitHub源码

1、ThreadMode，所执行的线程

  1. public enum ThreadMode {
  2.     /**
  3.      * current thread
  4.      */
  5.     CURRENT_THREAD,
  6.  
  7.     /**
  8.      * android main thread
  9.      */
  10.     MAIN,
  11.  
  12.  
  13.     /**
  14.      * new thread
  15.      */
  16.     NEW_THREAD
  17. }

2、Subscribe，注解

  1. @Documented
  2. @Target(ElementType.METHOD)
  3. @Retention(RetentionPolicy.RUNTIME)
  4. public @interface Subscribe {
  5.     int code() default -1;
  6.  
  7.     ThreadMode threadMode() default ThreadMode.CURRENT_THREAD;
  8. }

3、SubscriberMethod，存储订阅者的相关信息，并提供invoke调用

  1. public class SubscriberMethod {
  2.     public Method method;
  3.     public ThreadMode threadMode;
  4.     public Class<?> eventType;
  5.     public Object subscriber;
  6.     public int code;
  7.     public boolean originalIsPrimitive;//原始类型是否为基本类型
  8.  
  9.     public SubscriberMethod(Object subscriber, Method method, Class<?> eventType, int code, ThreadMode threadMode, boolean originalIsPrimitive) {
  10.         this.method = method;
  11.         this.threadMode = threadMode;
  12.         this.eventType = eventType;
  13.         this.subscriber = subscriber;
  14.         this.code = code;
  15.         this.originalIsPrimitive = originalIsPrimitive;
  16.     }
  17.  
  18.  
  19.     /**
  20.      * 调用方法
  21.      *
  22.      * @param o 参数
  23.      */
  24.     public void invoke(Object o) {
  25.         try {
  26.             Class[] parameterType = method.getParameterTypes();
  27.             if (parameterType != null && parameterType.length == 1) {
  28.                 method.invoke(subscriber, o);
  29.             } else if (parameterType == null || parameterType.length == 0) {
  30.                 method.invoke(subscriber);
  31.             }
  32.         } catch (IllegalAccessException e) {
  33.             e.printStackTrace();
  34.         } catch (InvocationTargetException e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }

4、PrimitiveBox，基本类型转换成对象类型

  1. public class PrimitiveBox {
  2.  
  3.     /**
  4.      * 装箱
  5.      *
  6.      * @param target 目标类
  7.      * @return 转换后的Class
  8.      */
  9.     public static Class<?> mantle(final Class<?> target) {
  10.         if (boolean.class.equals(target)) {
  11.             return Boolean.class;
  12.         } else if (char.class.equals(target)) {
  13.             return Character.class;
  14.         } else if (byte.class.equals(target)) {
  15.             return Byte.class;
  16.         } else if (short.class.equals(target)) {
  17.             return Short.class;
  18.         } else if (int.class.equals(target)) {
  19.             return Integer.class;
  20.         } else if (long.class.equals(target)) {
  21.             return Long.class;
  22.         } else if (float.class.equals(target)) {
  23.             return Float.class;
  24.         } else if (double.class.equals(target)) {
  25.             return Double.class;
  26.         } else {
  27.             return target;
  28.         }
  29.     }
  30. }

5、BusData，默认的事件类型

  1. public class BusData {
  2.     String id;
  3.     String status;
  4.     public BusData() {}
  5.     public BusData(String id, String status) {
  6.         this.id = id;
  7.         this.status = status;
  8.     }
  9.  
  10.     public String getId() {
  11.         return id;
  12.     }
  13.  
  14.     public void setId(String id) {
  15.         this.id = id;
  16.     }
  17.  
  18.     public String getStatus() {
  19.         return status;
  20.     }
  21.  
  22.     public void setStatus(String status) {
  23.         this.status = status;
  24.     }
  25. }

6、RxBus，核心类

  1. public class RxBus {
  2.     public static final String TAG = "RxBus_log";
  3.     private static volatile RxBus defaultInstance;
  4.  
  5.     /**
  6.      * key==》订阅者对象，value==》订阅事件（disposable ）
  7.      */
  8.     private Map<Object, List<Disposable>> subscriptionsByEventType = new HashMap<>();
  10.     /**
  11.      * key==》订阅者对象，value==》事件类型
  12.      * <p>
  13.      * value是 根据Key所注解的方法的参数类型确定，默认==》BusData，如：
  14.      * <p>
  15.      * 注解方法==》a()，则value==》BusData
  16.      * 注解方法==》a(String str)，则value==》String
  17.      */
  18.     private Map<Object, List<Class>> eventTypesBySubscriber = new HashMap<>();
  20.     /**
  21.      * key==》事件类型，value==》订阅者信息
  22.      * <p>
  23.      * value信息包括：订阅者对象（subscriber）, 方法名（method）, 事件类型（eventType）, 事件code（code）, 线程类型（threadMode）
  24.      */
  25.     private Map<Class, List<SubscriberMethod>> subscriberMethodByEventType = new HashMap<>();
  27.     private final Subject<Object> bus;
  28.  
  29.     private RxBus() {
  30.         this.bus = PublishSubject.create().toSerialized();
  31.     }
  32.  
  33.     public static RxBus getDefault() {
  34.         RxBus rxBus = defaultInstance;
  35.         if (defaultInstance == null) {
  36.             synchronized (RxBus.class) {
  37.                 rxBus = defaultInstance;
  38.                 if (defaultInstance == null) {
  39.                     rxBus = new RxBus();
  40.                     defaultInstance = rxBus;
  41.                 }
  42.             }
  43.         }
  44.         return rxBus;
  45.     }
  46.  
  47.     /**
  48.      * 注册
  49.      *
  50.      * @param subscriber 订阅者
  51.      */
  52.     public void register(Object subscriber) {
  53.         YLogUtil.logD2Tag(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@注册@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@--订阅者对象", subscriber);
  54.         //根据对象获取类
  55.         Class<?> subClass = subscriber.getClass();
  56.         //获取所有方法名
  57.         Method[] methods = subClass.getDeclaredMethods();
  58.         for (Method method : methods) {
  59.             //判断方法是否存在注解
  60.             if (method.isAnnotationPresent(Subscribe.class)) {
  61.                 //获得参数类型
  62.                 Class[] parameterType = method.getParameterTypes();
  63.                 //参数不为空 且参数个数为1
  64.                 if (parameterType != null && parameterType.length == 1) {
  65.  
  66.                     Class eventType = parameterType[0];
  67.                     executeRegistered(subscriber, method, eventType);
  68.  
  69.                 } else if (parameterType == null || parameterType.length == 0) {
  70.  
  71.                     Class eventType = BusData.class;
  72.                     executeRegistered(subscriber, method, eventType);
  73.  
  74.                 }
  75.             }
  76.         }
  77.         YLogUtil.logD2Tag(TAG, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@注册完成@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@--订阅者对象", subscriber);
  78.     }
  79.  
  80.     /**
  81.      * 取消注册
  82.      *
  83.      * @param subscriber 订阅者
  84.      */
  85.     public void unregister(Object subscriber) {
  86.         YLogUtil.logD2Tag(TAG, "###################################取消注册###################################--订阅者对象", subscriber);
  87.         //通过订阅者对象，获取对应的事件类型集合
  88.         List<Class> subscribedTypes = eventTypesBySubscriber.get(subscriber);
  89.         if (subscribedTypes != null) {
  90.             for (Class<?> eventType : subscribedTypes) {
  91.                 unSubscribeByEventType(subscriber);
  92.                 unSubscribeMethodByEventType(subscriber, eventType);
  93.                 YLogUtil.logD2Tag(TAG, "执行取消注册--订阅者对象", subscriber, "事件类型", eventType);
  94.             }
  95.             eventTypesBySubscriber.remove(subscriber);
  96.         }
  97.         YLogUtil.logD2Tag(TAG, "###################################取消注册完成###############################--订阅者对象", subscriber);
  98.     }
  99.  
  100.     /**
  101.      * 是否注册
  102.      *
  103.      * @param subscriber 订阅者
  104.      * @return
  105.      */
  106.     public synchronized boolean isRegistered(Object subscriber) {
  107.         boolean isRegistered = eventTypesBySubscriber.containsKey(subscriber);
  108.         YLogUtil.logD2Tag(TAG, "************************************判断是否注册******************************--订阅者对象", subscriber, "是？", isRegistered);
  109.         return isRegistered;
  110.     }
  111.  
  112.     /**
  113.      * 执行注册
  114.      *
  115.      * @param subscriber 订阅者对象
  116.      * @param method     方法名
  117.      * @param eventType  事件类型
  118.      */
  119.     private void executeRegistered(Object subscriber, Method method, Class eventType) {
  120.         //判断是否为基本类型
  121.         boolean isPrimitive = eventType.isPrimitive();
  122.         if (isPrimitive) {
  123.             YLogUtil.logD2Tag(TAG, "*********基础类型自动装箱---开始*********装箱前类型", eventType);
  124.             eventType = PrimitiveBox.mantle(eventType);
  125.             YLogUtil.logD2Tag(TAG, "*********基础类型自动装箱---完成*********装箱后类型", eventType);
  126.         }
  127.         // key==》订阅者对象，value==》事件类型，保存到map里
  128.         addEventTypeToMap(subscriber, eventType);
  129.  
  130.         //获取注解
  131.         Subscribe sub = method.getAnnotation(Subscribe.class);
  132.         int code = sub.code();
  133.         ThreadMode threadMode = sub.threadMode();
  134.  
  135.         //key==》事件类型，value==》订阅者信息，保存到map里
  136.         SubscriberMethod subscriberMethod = new SubscriberMethod(subscriber, method, eventType, code, threadMode, isPrimitive);
  137.         addSubscriberToMap(eventType, subscriberMethod);
  138.  
  139.         //添加到RxJava订阅
  140.         addSubscriber(subscriberMethod);
  141.  
  142.         YLogUtil.logD2Tag(TAG, "执行注册---方法:", method, "---事件类型:", eventType);
  143.     }
  144.  
  145.     /**
  146.      * key==》订阅者对象，value==》事件类型，保存到map里
  147.      *
  148.      * @param subscriber 订阅者对象
  149.      * @param eventType  事件类型
  150.      */
  151.     private void addEventTypeToMap(Object subscriber, Class eventType) {
  152.         List<Class> eventTypes = eventTypesBySubscriber.get(subscriber);
  153.         if (eventTypes == null) {
  154.             eventTypes = new ArrayList<>();
  155.             eventTypesBySubscriber.put(subscriber, eventTypes);
  156.         }
  157.         if (!eventTypes.contains(eventType)) {
  158.             eventTypes.add(eventType);
  159.         }
  160.     }
  161.  
  162.     /**
  163.      * key==》事件类型，value==》订阅者信息，保存到map里
  164.      *
  165.      * @param eventType        事件类型
  166.      * @param subscriberMethod 订阅者信息
  167.      */
  168.     private void addSubscriberToMap(Class eventType, SubscriberMethod subscriberMethod) {
  169.         List<SubscriberMethod> subscriberMethods = subscriberMethodByEventType.get(eventType);
  170.         if (subscriberMethods == null) {
  171.             subscriberMethods = new ArrayList<>();
  172.             subscriberMethodByEventType.put(eventType, subscriberMethods);
  173.         }
  174.         if (!subscriberMethods.contains(subscriberMethod)) {
  175.             subscriberMethods.add(subscriberMethod);
  176.         }
  177.     }
  178.  
  179.  
  180.     /**
  181.      * 用RxJava添加订阅者
  182.      *
  183.      * @param subscriberMethod 订阅者信息
  184.      */
  185.     @SuppressWarnings("unchecked")
  186.     private void addSubscriber(final SubscriberMethod subscriberMethod) {
  187.         Flowable flowable;
  188.         if (subscriberMethod.code == -1) {
  189.             flowable = toObservable(subscriberMethod.eventType);
  190.         } else {
  191.             flowable = toObservable(subscriberMethod.code, subscriberMethod.eventType);
  192.         }
  193.         Disposable subscription = postToObservable(flowable, subscriberMethod)
  194.                 .subscribe(new Consumer<Object>() {
  195.                     @Override
  196.                     public void accept(Object o) throws Exception {
  197.                         callEvent(subscriberMethod, o);
  198.                     }
  199.                 });
  200.         //key==》订阅者对象，value==》订阅事件（disposable ）
  201.         addSubscriptionToMap(subscriberMethod.subscriber, subscription);
  202.     }
  203.  
  204.     /**
  205.      * 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
  206.      *
  207.      * @param eventType 事件类型
  208.      * @return return
  209.      */
  210.     public <T> Flowable<T> toObservable(Class<T> eventType) {
  211.         //ofType(class)  指定某个类型的class，过滤属于这个类型的的结果，其它抛弃
  212.         return bus.toFlowable(BackpressureStrategy.BUFFER).ofType(eventType);
  213.     }
  214.  
  215.     /**
  216.      * 根据传递的code和 eventType 类型返回特定类型(eventType)的 被观察者
  217.      *
  218.      * @param code      事件code
  219.      * @param eventType 事件类型
  220.      */
  221.     private <T> Flowable<T> toObservable(final int code, final Class<T> eventType) {
  222.         //ofType(class)  指定某个类型的class，过滤属于这个类型的的结果，其它抛弃
  223.         return bus.toFlowable(BackpressureStrategy.BUFFER).ofType(Message.class)
  224.                 //采用filter（）变换操作符
  225.                 .filter(new Predicate<Message>() {
  226.                     // 根据test()的返回值 对被观察者发送的事件进行过滤 & 筛选
  227.                     // a. 返回true，则继续发送
  228.                     // b. 返回false，则不发送（即过滤）
  229.                     @Override
  230.                     public boolean test(Message o) throws Exception {
  231.                         return o.getCode() == code && eventType.isInstance(o.getObject());
  232.                     }
  233.                     // map操作符，Function<Object,Object>，只要类型为Object的子类就可以进行转换
  234.                 }).map(new Function<Message, Object>() {
  235.                     @Override
  236.                     public Object apply(Message o) throws Exception {
  237.                         return o.getObject();
  238.                     }
  239.                 }).cast(eventType);
  240.     }
  241.  
  242.     /**
  243.      * 用于处理订阅事件在那个线程中执行
  244.      *
  245.      * @param observable       订阅事件
  246.      * @param subscriberMethod 订阅者信息
  247.      * @return Observable
  248.      */
  249.     private Flowable postToObservable(Flowable observable, SubscriberMethod subscriberMethod) {
  250.         Scheduler scheduler;
  251.         switch (subscriberMethod.threadMode) {
  252.             case MAIN:
  253.                 scheduler = AndroidSchedulers.mainThread();
  254.                 break;
  255.  
  256.             case NEW_THREAD:
  257.                 scheduler = Schedulers.newThread();
  258.                 break;
  259.  
  260.             case CURRENT_THREAD:
  261.                 scheduler = Schedulers.trampoline();
  262.                 break;
  263.             default:
  264.                 throw new IllegalStateException("Unknown thread mode: " + subscriberMethod.threadMode);
  265.         }
  266.         return observable.observeOn(scheduler);
  267.     }
  268.  
  269.     /**
  270.      * key==》订阅者对象，value==》订阅事件（disposable ）
  271.      *
  272.      * @param subscriber 订阅者对象
  273.      * @param disposable 订阅事件
  274.      */
  275.     private void addSubscriptionToMap(Object subscriber, Disposable disposable) {
  276.         List<Disposable> disposables = subscriptionsByEventType.get(subscriber);
  277.         if (disposables == null) {
  278.             disposables = new ArrayList<>();
  279.             subscriptionsByEventType.put(subscriber, disposables);
  280.         }
  281.         if (!disposables.contains(disposable)) {
  282.             disposables.add(disposable);
  283.         }
  284.     }
  285.  
  286.  
  287.     /**
  288.      * 回调到订阅者的方法中
  289.      *
  290.      * @param subscriberMethod 订阅者信息
  291.      * @param object           事件类型对象
  292.      */
  293.     private void callEvent(SubscriberMethod subscriberMethod, Object object) {
  294.         YLogUtil.logD2Tag(TAG, "执行回调----订阅者对象", subscriberMethod.subscriber, "方法", subscriberMethod.method, "事件类型对象", object);
  295.         //因为最终发送的为事件类型对象
  296.         //所以需要通过事件类型对象，获取对应的事件类型
  297.         Class eventClass = object.getClass();
  298.         //通过事件类型，获取订阅者信息
  299.         List<SubscriberMethod> subscriberMethodList = subscriberMethodByEventType.get(eventClass);
  300.         //判断订阅者信息是否相同，并回调订阅者
  301.         if (subscriberMethodList != null && subscriberMethodList.size() > 0) {
  302.             for (SubscriberMethod tmpSubscriberMethod : subscriberMethodList) {
  303.                 if (tmpSubscriberMethod.code == subscriberMethod.code && subscriberMethod.subscriber.equals(tmpSubscriberMethod.subscriber)
  304.                         && subscriberMethod.method.equals(tmpSubscriberMethod.method)) {
  305.                     tmpSubscriberMethod.invoke(object);
  306.                     YLogUtil.logD2Tag(TAG, "回调成功----订阅者对象", subscriberMethod.subscriber, "方法", subscriberMethod.method, "事件类型对象", object);
  307.                 }
  308.  
  309.             }
  310.         }
  311.     }
  312.  
  313.     /**
  314.      * 移除订阅者对象对应的订阅事件
  315.      *
  316.      * @param subscriber 订阅者对象
  317.      */
  318.     private void unSubscribeByEventType(Object subscriber) {
  319.         List<Disposable> disposables = subscriptionsByEventType.get(subscriber);
  320.         if (disposables != null) {
  321.             Iterator<Disposable> iterator = disposables.iterator();
  322.             while (iterator.hasNext()) {
  323.                 Disposable disposable = iterator.next();
  324.                 if (disposable != null && !disposable.isDisposed()) {
  325.                     disposable.dispose();
  326.                     iterator.remove();
  327.                 }
  328.             }
  329.         }
  330.     }
  331.  
  332.     /**
  333.      * 移除订阅者对象对应的订阅者信息
  334.      *
  335.      * @param subscriber 订阅者对象
  336.      * @param eventType  事件类型
  337.      */
  338.     private void unSubscribeMethodByEventType(Object subscriber, Class eventType) {
  339.         //通过事件类型，获取订阅者信息
  340.         List<SubscriberMethod> subscriberMethods = subscriberMethodByEventType.get(eventType);
  341.         //判断订阅者信息的订阅者对象是否相同
  342.         if (subscriberMethods != null) {
  343.             Iterator<SubscriberMethod> iterator = subscriberMethods.iterator();
  344.             while (iterator.hasNext()) {
  345.                 SubscriberMethod subscriberMethod = iterator.next();
  346.                 if (subscriberMethod.subscriber.equals(subscriber)) {
  347.                     iterator.remove();
  348.                 }
  349.             }
  350.         }
  351.     }
  352.  
  353.     public void send(int code, Object o) {
  354.         Message message = new Message(code, o);
  355.         bus.onNext(message);
  356.         YLogUtil.logD2Tag(TAG, "发送RxBus", o);
  357.     }
  358.  
  359.     public void post(Object o) {
  360.         bus.onNext(o);
  361.     }
  362.  
  363.     public void send(int code) {
  364.         Message message = new Message(code, new BusData());
  365.         bus.onNext(message);
  366.         YLogUtil.logD2Tag(TAG, "发送RxBus", message.object);
  367.     }
  368.  
  369.     private class Message {
  370.         private int code;
  371.         private Object object;
  372.  
  373.         public Message() {
  374.         }
  375.  
  376.         private Message(int code, Object o) {
  377.             this.code = code;
  378.             this.object = o;
  379.         }
  380.  
  381.         private int getCode() {
  382.             return code;
  383.         }
  384.  
  385.         public void setCode(int code) {
  386.             this.code = code;
  387.         }
  388.  
  389.         private Object getObject() {
  390.             return object;
  391.         }
  392.  
  393.         public void setObject(Object object) {
  394.             this.object = object;
  395.         }
  396.     }
  397. }

 

RxBus使用方式

一、注册RxBus：

  1. public class TestActivity extends Activity{
  2.  
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) {
  5.         super.onCreate(savedInstanceState);
  6.         
  7.         RxBus.getDefault().register(this);
  8.     }
  9.  
  10.  
  11.     @SuppressLint("测试1，参数为String类型")
  12.     @Subscribe(code = 1001, threadMode = ThreadMode.MAIN)
  13.     public void rxBusTest1(String msg) {
  14.        
  15.     }
  16.  
  17.     @SuppressLint("测试2，参数为int基本数据类型")
  18.     @Subscribe(code = 1002, threadMode = ThreadMode.MAIN)
  19.     public void rxBusTest2(int type) {
  20.        
  21.     }
  22.  
  23.     @SuppressLint("测试3，参数为自定义对象")
  24.     @Subscribe(code = 1003, threadMode = ThreadMode.MAIN)
  25.     public void rxBusTest3(MsgData msgData) {
  26.        
  27.     }
  28.  
  29.  
  30.     @SuppressLint("测试4，无参")
  31.     @Subscribe(code = 1004, threadMode = ThreadMode.MAIN)
  32.     public void rxBusTest4() {
  33.        
  34.     }
  35.  
  36.     @Override
  37.     protected void onDestroy() {
  38.         super.onDestroy();
  39.         
  40.         RxBus.getDefault().unregister(this);
  41.     }
  42.  
  43. }

二、发送RxBus:

  1. RxBus.getDefault().send(1001,"hihi");
  2.  
  3. RxBus.getDefault().send(1002,123);
  4.  
  5. RxBus.getDefault().send(1003,new MsgData(111,"test"));
  6.  
  7. RxBus.getDefault().send(1004);

 

  1. public class MsgData {
  2.     public int code;
  3.     public String msg;
  4.  
  5.     public MsgData (int code, String msg) {
  6.         this.code = code;
  7.         this.msg = msg;
  8.     }
  9. }

 

混淆：

  1. #如RxBus所在包名为com.cn.rxbus
  2.  
  3. #Rxbus混淆
  4. -dontwarn com.cn.rxbus.**
  5. -keep class com.cn.rxbus.** { *;}
  6. -keepattributes *Annotation
  7. -keep @com.cn.rxbus.Subscribe class * {*;}
  8. -keep class * {
  9.     @com.cn.rxbus.Subscribe <fields>;
  10. }
  11. -keepclassmembers class * {
  12.     @com.cn.rxbus.Subscribe <methods>;
  13. }
  14. #Rxbus混淆end

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/291825
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号