RxJava 基础使用讲

最新推荐文章于 2024-11-07 00:02:10 发布

小白的成长之路_

最新推荐文章于 2024-11-07 00:02:10 发布

阅读量390

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/XiaoZhuang__/article/details/79200268

本文详细介绍了RxJava的原理及两种使用方式：分步骤实现和基于事件流的链式调用，并通过示例代码展示了如何创建被观察者、观察者以及如何通过订阅连接两者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Rxjava由于其基于事件流的链式调用（构建者模式）、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。
RxJava原理（观察者模式）可总结为：被观察者（Observable）通过订阅（Subscribe）按顺序发送事件给观察者（Observer），观察者（Observer）按顺序接收事件 & 作出对应的响应动作

Rxjava的使用方式有两种：

1.分步骤实现：该方法主要为了深入说明Rxjava的原理 & 使用，主要用于演示说明

//首先写一个被观察者的接口

  public interface Myobserveable {
    //方法1   //订阅的方法
    void subcride(Myobserve myobserve);
    //方法2   取消订阅
    void unsubcride(Myobserve myobserve);
    //发送报纸
    void send(News news);
  }
//实现该接口的类
public class NewsPepar implements Myobserveable{
    //观察者列表,就是用户的订阅数量
    List<Myobserve> list=new ArrayList<>();
    @Override
    public void subcride(Myobserve myobserve) {
        if(myobserve==null){
            return;
        }
        if(!list.contains(myobserve)){//判断是否存在这个用户
            //添加到列表
            list.add(myobserve);
        }
    }

    @Override
    public void unsubcride(Myobserve myobserve) {
               if(myobserve==null){
                  return;
               }
               if(!list.contains(myobserve)){
                    list.remove(myobserve);
               }
    }
     //发送给观察者
    @Override
    public void send(News news) {
           if(list!=null&&list.size()>0){
               for (int i = 0; i <list.size() ; i++) {
                   list.get(i).receive(news);
               }
           }
    }
}

//写一个观察者的接口

public interface Myobserve {
    //接收订阅的方法
    void receive(News news);
}

//实现观察者的类

public class User implements Myobserve{
    @Override
    public void receive(News news) {
        System.out.println(news.getTitle()+"=="+news.getContent());
    }
}

//因为一般穿的都是对象

/**
 * 报社的报纸对象
 */

public class News {
    private String title;
    private String content;

    public News(String title, String content) {
        this.title = title;
        this.content = content;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

//在test 单元测试一下

public class Test {
    public static void main(String[] msg){
        //获取被观察者对象
        Myobserveable myobserveable=new NewsPepar();
        //创建观察者
        Myobserve myobserve1=new User();
        Myobserve myobserve2=new User();
        //订阅信息
        myobserveable.subcride(myobserve1);
        myobserveable.subcride(myobserve2);
        //发送报纸  也就是订阅信息
          myobserveable.send(new News("今天学的很差","因为自己懒惰所致"));
    }
}

2.基于事件流的链式调用：主要用于实际使用

//也是才测试类中实现 ,简单的实现

步骤1：加入依赖

compile 'io.reactivex.rxjava2:rxjava:2.0.1'

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

创建被观察者（Observable ）& 生产事件

创建观察者（Observer ）并定义响应事件的行为

通过订阅（Subscribe）连接观察者和被观察者

public class RxJavaTest {
    public static void main(String[] msg){
        //通过依赖RxJava库

        //方式1：分步骤实现
        // 1. 创建被观察者 Observable 对象 ,通过创建操作符创建observable对象
        Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
            // 2. 在复写的subscribe（）里定义需要发送的事件
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                // ObservableEmitter类介绍
                // a. 定义：事件发射器
                // b. 作用：定义需要发送的事件 & 向观察者发送事件
                e.onNext("小明");
                e.onNext("小白");
                e.onNext("小黑");
                e.onError(new Throwable("发送失败"));//异常和成功的方法不能同时使用
                //e.onComplete();
            }
        });

        //步骤2：创建观察者 Observer 并 定义响应事件行为
        Observer<String > observer=new Observer<String>() {
            //通过复写对应方法来 响应 被观察者
            //判断是否连接成功
            @Override
            public void onSubscribe(Disposable d) {
                // 默认最先调用复写的 onSubscribe（）
                   System.out.println("Disposable"+d);
            }
             /*
             * 消费的方法,value就是被观察者发过来的信息,这里是string,一般都是对象
             * */
            @Override
            public void onNext(String value) {
                System.out.println("onNext"+value);
            }
              //发生异常
            @Override
            public void onError(Throwable e) {
                System.out.println("onError"+e);
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        };
        // 步骤3：通过订阅（subscribe）连接观察者和被观察者
          //observable.subscribe(observer);


        //3.2    方式2：基于事件流的链式调用方式 (1)
        Observable.create(new ObservableOnSubscribe<News>() {
            // 1. 创建被观察者 & 生产事件
            @Override
            public void subscribe(ObservableEmitter<News> e) throws Exception {
                 e.onNext(new News("小庄","要更努力"));
            }
        }).subscribe(new Observer<News>() {
            // 2. 通过通过订阅（subscribe）连接观察者和被观察者
            // 3. 创建观察者 & 定义响应事件的行为
            @Override
            public void onSubscribe(Disposable d) {
                // 默认最先调用复写的 onSubscribe（） 开始连接
                System.out.print("Disposable"+d);
            }

            @Override
            public void onNext(News value) {
                //接收信息  作出相应
                System.out.println("onNext"+value.getTitle()+"=="+value.getContent());
            }

            @Override
            public void onError(Throwable e) {
                //失败
            }

            @Override
            public void onComplete() {
               //成功
            }
        });

        //基于事件流的链式调用方式 (2)
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(5);
                e.onNext(10);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                // 表示观察者只对被观察者发送的Next事件作出响应
                System.out.println(integer);
            }
        });

        //just操作符链式调用  just里面存放事件,这些事件都是对象
        Observable.just(new News("AA","BB"),new News("aa","bb"))
                .subscribe(new Consumer<News>() {
                    @Override
                    public void accept(News news) throws Exception {
                         System.out.println(news.getTitle()+"=="+news.getContent());
                    }
                });
        //from操作符链式调用
        String[] str=new String[]{"aa","bb","cc"};
        Observable.fromArray(str)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(s);
                    }
                });
    }
}

3. 额外说明

3.1 观察者 Observer的subscribe()具备多个重载的方法

public final Disposable subscribe() {} // 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）

public final Disposable subscribe(Consumer<? super T> onNext) {} // 表示观察者只对被观察者发送的Next事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}// 表示观察者只对被观察者发送的Next事件 & Error事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {} // 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应

public final void subscribe(Observer<? super T> observer) {} // 表示观察者对被观察者发送的任何事件都作出响应

3.2 可采用 Disposable.dispose() 切断观察者 与 被观察者 之间的连接