Android RxBus类使用-可直接使用-Android笔记

最新推荐文章于 2024-08-10 07:35:59 发布
最新推荐文章于 2024-08-10 07:35:59 发布
阅读量8.6w 收藏 1
点赞数 2
分类专栏： Utils 文章标签： Android RxBus RxBus RxBus使用 RxBus详解 RxBus选择
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GodDavide/article/details/80198548
版权

至于RxBus的原理在这儿就不讲了，这儿附上两个RxBus类和使用方法，一个只有两个方法（构造方法和发送消息方法），另一个多了事件订阅、取消时间订阅等一些方法。我使用的是第一个，因为第二个中多余的方法根本用不到... ...

还请大牛指点其中要害之处及利弊关系！感激不尽！！！

--------------------start---------------

废话不多说，两个分别展示一下：

再啰嗦一句：jar包别忘了！

compile 'io.reactivex:rxjava:1.0.14'
compile 'io.reactivex:rxandroid:1.0.1'

一：简单RxBus类及使用方法：（推荐）

1：RxBus类：

public class RxBus {
    private static volatile RxBus defaultInstance;

    private final Subject<Object, Object> bus;
    // PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者
    public RxBus() {
        bus = new SerializedSubject<>(PublishSubject.create());
    }
    // 单例RxBus
    public static RxBus getDefault() {
        if (defaultInstance == null) {
            synchronized (RxBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new RxBus();
                }
            }
        }
        return defaultInstance ;
    }
    // 发送一个新的事件
    public void post (Object o) {
        bus.onNext(o);
    }
    // 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
    public <T> Observable<T> toObservable (Class<T> eventType) {
        return bus.ofType(eventType); 
    }
}

2：使用方法：

    2.1：在你想接收消息的地方订阅事件！注：任何地方

    /**
     * 事件监听
     */
    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN)
    public void doSubscribe() {

        RxBus.getDefault().toObservable(RxBean.class)
                //在io线程进行订阅，可以执行一些耗时操作
                .subscribeOn(Schedulers.io())
                //在主线程进行观察，可做UI更新操作
                .observeOn(AndroidSchedulers.mainThread())
                //观察的对象
                .subscribe(new Action1<RxBean>() {
                    @Override
                    public void call(RxBean rxBean) {
                        /** 
                         *create by Davide
                         *我这里只有一个Bean类，是通过status区分消息类型的，当然你可以分别注测不同的Bean类
                         */
                        switch (rxBean.getStatus()) {
                            case 0:
//                                ... ...
                                break;
                            case 1: 
//                                ... ...
                                break;
                            default:
                                break;
                        }
                    }
                });
    }

    2.2：发送消息

RxBus.getDefault().post(new RxBean(Config.GAME_DETAIL_CURRENT_PAGE, 
        "你可以通过自定义构造方法，发送任意你需要的参数"));

    2.3：附上我的RxBean类吧，我懒，将所有的东西全部写在了一个Bean类里，通过不同的status区分消息类型，通过不同的构造方法传递参数。随着开发不断进行，不断添加构造方法，感觉比挨个写类方便多了，但是我还是想问问各位大牛们，这样会不会有什么弊端？

/**
 * @author Davide  create on 17/7/31.
 * @email suwei@acooo.cn
 * Learn from yesterday, live for today, hope for tomorrow.
 */

public class RxBean {

    private int status;
    private int intId;
    private String id;
    private String imageUrl;
    private DownloadTask task;
    private boolean isTrue;
    private boolean hasFocus;
    private int focusIndex;
    private String apkName;
    private Uri uri;
    private MotionEvent event;
    private View view;

    public RxBean(int status, MotionEvent event) {
        this.status = status;
        this.event = event;
    }

    public RxBean(int status, Uri uri) {
        this.status = status;
        this.uri = uri;
    }

    public RxBean(int i, View view) {
        this.status = i;
        this.view = view;

    }

    public RxBean(int status, boolean isTrue) {
        this.status = status;
        this.isTrue = isTrue;
    }

    public RxBean(int status, int intId) {
        this.status = status;
        this.intId = intId;
    }

    public RxBean(int status, String id, int focusIndex) {
        this.status = status;
        this.id = id;
        this.focusIndex = focusIndex;
    }

    public RxBean(int movieFocusView, View v, boolean hasFocus) {
        this.status = movieFocusView;
        this.view = v;
        this.hasFocus = hasFocus;
    }

    public RxBean(int status, String id) {
        this.status = status;
        this.id = id;
    }

    public RxBean(int status, String id, boolean isTrue, DownloadTask task) {
        this.status = status;
        this.id = id;
        this.isTrue = isTrue;
        this.task = task;
    }

    public RxBean(int status, String id, boolean isTrue) {
        this.status = status;
        this.id = id;
        this.isTrue = isTrue;
    }

    public RxBean(int status, DownloadTask task) {
        this.status = status;
        this.task = task;
    }

    public RxBean(int status, String id, String imageUrl) {
        this.status = status;
        this.id = id;
        this.imageUrl = imageUrl;
    }

    public RxBean(int status, boolean isTrue, int focusIndex) {
        this.status = status;
        this.isTrue = isTrue;
        this.focusIndex = focusIndex;
    }

    public RxBean(int gameFocuesChangeTrueId, String pName, boolean isTrue,
                  DownloadTask task, boolean hasFocus, int focusIndex, String apkName) {
        this.status = gameFocuesChangeTrueId;
        this.id = pName;
        this.isTrue = isTrue;
        this.task = task;
        this.hasFocus = hasFocus;
        this.focusIndex = focusIndex;
        this.apkName = apkName;
    }

    public View getView() {
        return view;
    }

    public void setView(View view) {
        this.view = view;
    }

    public MotionEvent getEvent() {
        return event;
    }

    public void setEvent(MotionEvent event) {
        this.event = event;
    }

    public Uri getUri() {
        return uri;
    }

    public void setUri(Uri uri) {
        this.uri = uri;
    }

    public String getApkName() {
        return apkName;
    }

    public void setApkName(String apkName) {
        this.apkName = apkName;
    }

    public int getFocusIndex() {
        return focusIndex;
    }

    public void setFocusIndex(int focusIndex) {
        this.focusIndex = focusIndex;
    }

    public boolean isHasFocus() {
        return hasFocus;
    }

    public void setHasFocus(boolean hasFocus) {
        this.hasFocus = hasFocus;
    }

    public boolean isTrue() {
        return isTrue;
    }

    public void setTrue(boolean aTrue) {
        isTrue = aTrue;
    }

    public int getIntId() {
        return intId;
    }

    public void setIntId(int intId) {
        this.intId = intId;
    }

    public String getImageUrl() {
        return imageUrl;
    }

    public void setImageUrl(String imageUrl) {
        this.imageUrl = imageUrl;
    }

    public DownloadTask getTask() {
        return task;
    }

    public void setTask(DownloadTask task) {
        this.task = task;
    }

    public RxBean(int status) {
        this.status = status;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "RxBean{" +
                "status=" + status +
                ", intId=" + intId +
                ", id='" + id + '\'' +
                ", imageUrl='" + imageUrl + '\'' +
                ", task=" + task +
                ", isTrue=" + isTrue +
                ", hasFocus=" + hasFocus +
                ", focusIndex=" + focusIndex +
                ", apkName='" + apkName + '\'' +
                ", uri=" + uri +
                ", event=" + event +
                ", view=" + view +
                '}';
    }
}


二：详细RxBean类：哪位大牛来帮我分析下利弊？

  1：RxBus类及工具类：

public class RxBus {

    private final Subject<Object, Object> bus;
    private Map<Object, List<Subscription>> subscriptions;

    private RxBus() {
        //非线程安全的PublishSubject包装成线程安全的SerializedSubject
        bus = new SerializedSubject<>(PublishSubject.create());
    }

    public static RxBus getDefault() {
        return SingletonHolder.INSTANCE;
    }

    /**
     * 发送事件
     *
     * @param event 事件对象
     */
    public void post(Object event) {
        if (bus.hasObservers()) {
            bus.onNext(event);
        }
    }

    /**
     * 订阅事件
     *
     * @param subscriber 订阅者
     * @param callback   事件回调
     * @param <T>        事件类型
     */
    public <T> void subscribe(Object subscriber, Callback<T> callback) {
        Class<T> eventType = RawType.getRawType(callback);
        Subscription subscription = bus.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .ofType(eventType)
                .subscribe(callback);
        add(subscriber, subscription);
    }

    /**
     * 订阅事件
     *
     * @param subscriber 订阅者
     * @param eventType  事件对象
     * @param callback   事件回调
     * @param <T>        事件类型
     */
    public <T> void subscribe(Object subscriber, Class<T> eventType, Callback<T> callback) {
        Subscription subscription = bus.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .ofType(eventType)
                .subscribe(callback);
        add(subscriber, subscription);
    }

    /**
     * 订阅事件
     *
     * @param eventType  事件对象
     * @param callback   事件回调
     * @param <T>        事件类型
     */
    public <T> Subscription subscribe(Class<T> eventType, Callback<T> callback) {
        return bus.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .ofType(eventType)
                .subscribe(callback);
    }

    /**
     * 订阅事件
     *
     * @param eventType 事件对象
     * @param <T>       事件类型
     * @return 特定类型的Observable
     */
    public <T> Observable<T> observe(Class<T> eventType) {
        return bus.ofType(eventType);
    }

    /**
     * 添加订阅协议
     *
     * @param subscriber   订阅者
     * @param subscription 订阅协议
     */
    public synchronized void add(Object subscriber, Subscription subscription) {
        if (subscriptions == null) {
            subscriptions = new HashMap<>();
        }

        List<Subscription> list = subscriptions.get(subscriber);
        if (list == null) {
            list = new ArrayList<>();
        }
        list.add(subscription);
        subscriptions.put(subscriber, list);
    }

    /**
     * 取消事件订阅
     *
     * @param subscriber 订阅者
     */
    public synchronized void unsubscribe(Object subscriber) {
        if (subscriptions == null) return;

        List<Subscription> list = subscriptions.get(subscriber);
        if (list == null || list.isEmpty()) return;

        for (Subscription subscription : list) {
            subscription.unsubscribe();
        }
        list.clear();
        subscriptions.remove(subscriber);
    }

    /**
     * 取消所有订阅
     */
    public void unsubscribeAll() {
        Set<Map.Entry<Object, List<Subscription>>> set = subscriptions.entrySet();
        for (Map.Entry<Object, List<Subscription>> entry : set) {
            List<Subscription> list = entry.getValue();
            for (Subscription subscription : list) {
                subscription.unsubscribe();
            }
            list.clear();
        }
        subscriptions = null;
    }

    private static class SingletonHolder {
        public static volatile RxBus INSTANCE = new RxBus();
    }

    public <T> Observable<T> toObservable (Class<T> eventType) {
        return bus.ofType(eventType);
    }

    public <T> Observable<T> IoToUiObservable(Class<T> eventType){
        return bus.ofType(eventType)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

}
public abstract class Callback<T> implements Action1<T> {
    /**
     * 监听到事件时回调接口
     *
     * @param t 返回结果
     */
    public abstract void onEvent(T t);

    @Override
    public void call(T t) {
        onEvent(t);
    }
}
public class RawType {
    public static <T> Class<T> getRawType(Callback<T> callback) {
        Type genericSuperclass = callback.getClass()
                .getGenericSuperclass();
        Type[] params = ((ParameterizedType) genericSuperclass).getActualTypeArguments();
        Type type = params[0];
        return (Class<T>) getRawType(type);
    }

    private static Class<?> getRawType(Type type) {
        if (type == null) throw new NullPointerException("type == null");

        if (type instanceof Class<?>) {
            // Type is a normal class.
            return (Class<?>) type;
        }
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;

            // I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
            // suspects some pathological case related to nested classes exists.
            Type rawType = parameterizedType.getRawType();
            if (!(rawType instanceof Class)) throw new IllegalArgumentException();
            return (Class<?>) rawType;
        }
        if (type instanceof GenericArrayType) {
            Type componentType = ((GenericArrayType) type).getGenericComponentType();
            return Array.newInstance(getRawType(componentType), 0)
                    .getClass();
        }
        if (type instanceof TypeVariable) {
            // We could use the variable's bounds, but that won't work if there are multiple. Having a raw
            // type that's more general than necessary is okay.
            return Object.class;
        }
        if (type instanceof WildcardType) {
            return getRawType(((WildcardType) type).getUpperBounds()[0]);
        }

        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or " + "GenericArrayType, but <" +
                type + "> is of type " + type.getClass()
                .getName());
    }
}

        2：使用方法基本相同：

            2.1：订阅事件略有不同

            定义全局变量

private CompositeSubscription mCompositeSubscription;  

            初始化：

mCompositeSubscription = new CompositeSubscription();

          订阅事件：

 mCompositeSubscription.add(RxBus.getDefault()
                .toObservable(RxBean.class)//bean类随意定义
                .sample(16, TimeUnit.MILLISECONDS)
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(totalJunkSizeEvent -> {
//                    ... ... 你的操作
                }, Throwable::printStackTrace));

        记得取消订阅：一般在Destroy等退出的地方，如果不取消订阅，可能会造成内存溢出或者页面无法销毁等，但是或许在有的时候你会选择故意不取消订阅也说不定！

if (mCompositeSubscription.isUnsubscribed()) {
    this.mCompositeSubscription.unsubscribe();
}
this.mCompositeSubscription = null;

    感觉有点复杂，其实关键的接收代码基本没差。

            2.2：发送消息

RxBus.getDefault().post(new RxBean(Config.GAME_DETAIL_CURRENT_PAGE, 
        "你可以通过自定义构造方法，发送任意你需要的参数,也可以自定义Bean类"));

        2.3： Bean类不再展示，随你定义


参考博文：丢失再见

-------------------------end-------------------

@ Name : David
@ email ：david.forever.god@gmail.com
Learn from yesterday, live for today, hope for tomorrow.
Davide~苏
关注
专栏目录
Android之RxBus详解
2301_79655511的博客
04-22 390
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的Android框架体系架构知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的Android框架体系架构知识脑图原件（包括上方的面试解析xmind文档）
Android之RxBus详解，Android基础入门教程
m0_65511857的博客
12-31 639
/** 发送一个新的事件 @param object */ public void post(Object object){ bus.onNext(object); } /** 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者 */ public Observable toObservable(Class eventType){ return bus.ofType(eventType); } } 首先我们要定义一个接受数据的实体类： public class
rxbus工具类keyizhijieyong
01-15
rxbus工具类,keyishizjieshiyogn,rxbus工具类,
android rxbus封装,Android RxBus的使用
weixin_39754831的博客
05-25 362
RxBus的核心功能是基于Rxjava的，在RxJava中有个Subject类，它继承Observable类，同时实现了Observer接口，因此Subject可以同时担当订阅者和被订阅者的角色，这里我们使用Subject的子类PublishSubject来创建一个Subject对象(PublishSubject只有被订阅后才会把接收到的事件立刻发送给订阅者)，在需要接收事件的地方，订阅该Subj...
RxBus开源项目安装与使用指南
最新发布
gitblog_00921的博客
08-10 350
RxBus开源项目安装与使用指南 RxBusEvent Bus By RxJava.项目地址:https://gitcode.com/gh_mirrors/rx/RxBus 目录结构及介绍 当你克隆或者下载RxBus的GitHub仓库后,你会看到下面的主要目录结构: . ├── app # 应用程序模块,包含示例代码 │ ├── src ...
Android RxBus的使用
Angelica
06-08 3662
RxBus的核心功能是基于Rxjava的，在RxJava中有个Subject类，它继承Observable类，同时实现了Observer接口，因此Subject可以同时担当订阅者和被订阅者的角色，这里我们使用Subject的子类PublishSubject来创建一个Subject对象（PublishSubject只有被订阅后才会把接收到的事件立刻发送给订阅者），在需要接收事件的地方，订阅该Subje
优雅保活方案，原来Android还可以这样保活！
2401_84046635的博客
04-01 967
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的Android框架体系架构知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的Android框架体系架构知识脑图原件（包括上方的面试解析xmind文档）
Android 用LiveDataBus替代RxBus、EvenBus
seven2729的专栏
03-13 656
实践是检验真理的唯一标准----古人说的话没错。希望能帮助到需要的人。下面是查阅的相关资料。有需要的可以去看看。原理什么的可以去了解一下下。我就不去复述照搬了。大家互相学习吧！共勉。
Android代码-饭否客户端源码.zip
08-02
2. **网络通信**：在Android应用中，网络通信是必不可少的部分。饭否客户端源码可能会使用Retrofit、Volley或者OkHttp等库来实现HTTP请求，同时结合Gson或Jackson处理JSON数据。通过分析这些网络请求的实现，我们...
黑马Android基础笔记
07-06
《黑马Android基础笔记》是一份全面且深入的Android开发学习资料，主要针对初学者和希望巩固基础知识的开发者。这份笔记涵盖了Android开发的核心概念和技术，旨在帮助读者构建坚实的Android开发基础。 1. **Android...
react-Rxbus基于rxjs的工具类解决React组件之间的通信
08-14
Rxbus基于rx.js的工具类，解决React组件之间的通信，抛弃复杂的redux以及mobx，
RxBus:RxBus for Android,通过RxBus来实现事件的通知和订阅，简化应用组件间的通信,解耦事件的发送者和接收者,避免复杂和容易出错的依赖和生命周期的问题
05-16
RxBus for Android 通过RxBus来实现事件的通知和订阅，简化应用组件间的通信,解耦事件的发送者和接收者,避免复杂和容易出错的依赖和生命周期的问题. 1. 依赖方式Dependency 1.1 Maven <dependency> <groupId>com.hanzhifengyun</groupId> <artifactId>rxbus</artifactId> <version>1.0.0</version> <type>pom</type> </dependency> 1.2 Gradle compile 'com.hanzhifengyun:rxbus:1.0.0' 2 如何使用Use 2.1 在合适的时机注册 @Override protected void onCreate(Bundle savedInstanceState) {
android rxbus github,RxBus RxBus 是一个发布/订阅模式的事件总线，用法和 EventBus 一样简单。RxBus 基于 RxJava @codeKK Android开...
weixin_35867815的博客
05-29 253
RxBus is a publish/subscribe event bus optimized for Android, like EventBus.RxBus Based on RxJava,it has a simple event bus as EventBus, but also the rich features of Rx Java.How to use1.Define EventD...
android rxbus github,RxBus的实现及简单使用
weixin_39945531的博客
05-29 152
RxJava目前已经很火了，如果你尚未了解请看这里。对于RxJava这里不多做介绍。RxBus并不是一个库，而是一种模式。相信大多数开发者都使用过EventBus，作为事件总线通信库，如果你的项目已经加入RxJava和EventBus，不妨用RxBus代替EventBus，以减少库的依赖。一、添加RxJava和RxAndroid依赖//RxJava and RxAndroidcompile 'io...
GitHub上AndroidKnife/RxBus用法
minyou_1314的专栏
12-21 2084
RxBus库简介 GitHub地址 https://github.com/AndroidKnife/RxBus 目前的版本是1.0.5 发送事件方法：RxBus.get().post(Constants.EventType.TAG_STORY, this); 接收事件方法：注册RxBus.get().register（this） 接收方法@Subscribe( thread = Ev
RxBus工具类
gsc_19970804的博客
01-31 372
package com.example.rxbusdemo; import io.reactivex.Flowable; import io.reactivex.processors.FlowableProcessor; import io.reactivex.processors.PublishProcessor; import io.reactivex.subscribers.
X86笔记本全程体验：Android 4.0安装与使用教程
随着Android for x86项目的发展，这个系统甚至可以被安装在个人计算机上，提供了一种全新的使用体验。 首先，作者提到尝试在笔记本上安装Android 4.0的原因。原因之一是Android在平板电脑模式下的响应速度和便捷性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值