RxJava详解(基于2.X版本)

最新推荐文章于 2024-05-10 00:44:01 发布

jianning-wu

最新推荐文章于 2024-05-10 00:44:01 发布

阅读量1.4k

点赞数 2

本文链接：https://blog.csdn.net/weixin_37730482/article/details/69280013

版权

Android RxJava 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

上节讲到基于1.X版本的RxJava的详解以及使用

https://blog.csdn.net/weixin_37730482/article/details/68059274

由于2.X和1.X变化比较大，所以本章节讲述基于2.X版本的RxJava。

一.基本使用基于2.X版本

1.Gradle依赖 RxJava&RxAndroid 版本须一致即都是2.x版本

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

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

2.代码

public class MainActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable<String> mObservable = null;
    private Disposable mDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }

    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                mDisposable = d;
                Log.d("TAG", "观察者 onSubscribe方法执行！！！断开----：" + mDisposable.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者 onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者 onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者 onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联
                if (!e.isDisposed()) {
                    e.onNext("被观察者对象 发出第1波数据......");
                    e.onNext("被观察者对象 发出第2波数据......");
                    e.onNext("被观察者对象 发出第3波数据......");
                    e.onComplete();
                }
            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

3. 结果

D/TAG: 观察者 onSubscribe方法执行！！！断开----：false

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第1波数据......

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第2波数据......

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第3波数据......

D/TAG: 观察者 onComplete方法执行！！！

4.关闭页面

D/TAG: onDestroy方法 执行时是否断开----：true

5.说明

<1> 观察者和被观察者发生订阅关系后。观察者才可收到被观察者发送的消息。

<2> 观察者模式，在适当的时候需要取消订阅。这样可以避免内存泄漏。具体做法。

2.X版本的RxJava发生订阅后会生成Disposable对象。可用此对象取消订阅。但是这种常规方式创建观察者时退出页面时 onSubscribe对象返回的Disposable对象已自动断开如上

<3> 可以看出2.X和1.X还是有很多区别的。

(1) 2.X版本创建观察者对象只有Observer接口一种方式。

(2) 2.X版本观察者重写的方法新加onSubscribe方法。开始采用subscribe连接。此方法可以切断和被观察者的关联。

(3) 2.X版本观察者重写的方法修改onComplete方法。 1.x：onCompleted方法。

(4) 2.X版本被观察者的创建还是用create操作符，但是重写的方法修改subscribe方法 1.x：call方法。

<3> 2.X版本增加了被观察者的新实现 Flowable 来支持背压Backpressure。

背压详解：https://blog.csdn.net/weixin_37730482/article/details/78085190

6.源码

上述可知，这种方式的观察者关闭页面时，onSubscribe对象返回的Disposable对象已自动断开。为什么呢？

原因在于被观察者中

Create方法创建被观察者

mObservable = Observable.create(new ObservableOnSubscribe() {
   
   ...

}

create方法源码

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

ObjectHelper.requireNonNull(source, "source is null");这行代码可以忽略。

return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));这行代码是重点

ObservableCreate<T>类源码

public final class ObservableCreate<T> extends Observable<T> {

    ...

}

该类中，有onNext方法，onError方法，onComplete方法。

onNext方法源码

@Override
public void onNext(T t) {
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    if (!isDisposed()) {
        observer.onNext(t);
    }
}

onError方法源码

public void onError(Throwable t) {
    if (t == null) {
        t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
    }
    if (!isDisposed()) {
        try {
            observer.onError(t);
        } finally {
            dispose();
        }
    } else {
        RxJavaPlugins.onError(t);
    }
}

onComplete方法源码

public void onComplete() {
    if (!isDisposed()) {
        try {
            observer.onComplete();
        } finally {
            dispose();
        }
    }
}

也就是说，在onError方法和onComplete方法中。都执行了dispose()方法。所以会自动断开。

二.观察者和被观察者的订阅方法的几个重载方法使用

上述观察者和被观察者发生订阅关系时代码如下

if (null != mObserver && null != mObservable) {
   mObservable.subscribe(mObserver);//完成订阅
}

即。订阅关系调用的subscribe方法。

其实subscribe方法有好几个重载的方法。满足不同的需求。

1. 传入Observer接口对象最常用的如上无返回值

public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

2.传入Consumer onNext对象返回值：Disposable 可用于断开订阅关系即观察者只监听onNext方法。

public final Disposable subscribe(Consumer<? super T> onNext) {
    return subscribe(onNext, Functions.ERROR_CONSUMER, Functions.EMPTY_ACTION, Functions.emptyConsumer());
}

3.传入 Consumer onNext对象+Consumer onError对象 返回值：Disposable 可用于断开订阅关系 即观察者监听onNext方法和onError方法。

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
    return subscribe(onNext, onError, Functions.EMPTY_ACTION, Functions.emptyConsumer());
}

4.传入 Consumer onNext对象+Consumer onError对象+Action onComplete对象返回值：Disposable 可用于断开订阅关系即观察者监听onNext方法和onError方法和onComplete方法。相当于Observer接口创建观察者。

public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete) {
    return subscribe(onNext, onError, onComplete, Functions.emptyConsumer());
}

5.2+3+4重载方法举例

代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;

public class MainActivity extends AppCompatActivity {

    private Observable<String> mObservable = null;
    private Disposable mDisposable;
    private Consumer mNextConsumer;
    private Action mCompleteAction;
    private Consumer<Throwable> mErrorConsumer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mNextConsumer && null != mCompleteAction && null != mErrorConsumer && null != mObservable) {
            mDisposable = mObservable.subscribe(mNextConsumer, mErrorConsumer, mCompleteAction);//完成订阅
        }

    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mNextConsumer = new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                if (null == o) {
                    return;
                }
                Log.d("TAG", "观察者 onNext方法执行！！！结果：" + o.toString());
            }
        };

        mErrorConsumer = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.d("TAG", "观察者 onError方法执行！！！");
            }
        };

        mCompleteAction = new Action() {
            @Override
            public void run() throws Exception {
                Log.d("TAG", "观察者 onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联
                if (!e.isDisposed()) {
                    e.onNext("被观察者对象 发出第1波数据......");
                    e.onNext("被观察者对象 发出第2波数据......");
                    e.onNext("被观察者对象 发出第3波数据......");
                    e.onComplete();
                }
            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

结果

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第1波数据......

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第2波数据......

D/TAG: 观察者 onNext方法执行！！！结果：被观察者对象 发出第3波数据......

D/TAG: 观察者 onComplete方法执行！！！

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：true

说明

<1> 这三个方法结合使用就相当于Observer接口创建观察者。也可以单独使用比如单独使用onNext对象接收被观察者发送的消息。

<2> 关闭页面时订阅产生的 Disposable对象已自动断开如上。原理上看。

<3> RxJava 2.x 提供了多个函数式接口，用于实现简便式的观察者模式。比如上面用的Action、Consumer等等具体如下图

三.2.X版本取消订阅关系

1.X版本的RxJava发生订阅后会生成Subscription对象。可用此对象取消订阅。当有多个订阅关系时，可以使用CompositeSubscription对象统一管理Subscription对象。然后统一取消订阅。

那么2.X版本如何做呢？因为2.X版本常规的观察者和被观察者发生订阅关系的方法。

mObservable.subscribe(mObserver);//完成订阅

方法返回值是 void类型即无返回值。

public final void subscribe(Observer<? super T> observer) {}

这种常规的操作是在观察者对象的onSubscribe方法中拿到Disposable对象(自动断开)，代码如上。

多个订阅关系举例代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;

public class MainActivity extends AppCompatActivity {

    private Observable<String> mObservable1 = null;
    private Observable<String> mObservable2 = null;

    private Disposable mDisposable1;
    private Disposable mDisposable2;
    private CompositeDisposable mCompositeDisposable;

    private Consumer mNextConsumer1;
    private Consumer mNextConsumer2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod1();//创建观察者对象1
        createObservableMethod1();//创建被观察者对象1
        if (null != mNextConsumer1 && null != mObservable1) {
            mDisposable1 = mObservable1.subscribe(mNextConsumer1);//完成订阅
        }

        createObserverMethod2();//创建观察者对象2
        createObservableMethod2();//创建被观察者对象2
        if (null != mNextConsumer2 && null != mObservable2) {
            mDisposable2 = mObservable2.subscribe(mNextConsumer2);//完成订阅
        }

        mCompositeDisposable = new CompositeDisposable();
        mCompositeDisposable.add(mDisposable1);
        mCompositeDisposable.add(mDisposable2);
    }

    /**
     * 创建 观察者对象1
     */

    public void createObserverMethod1() {
        mNextConsumer1 = new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                if (null == o) {
                    return;
                }
                Log.d("TAG", "观察者对象1 onNext方法执行！！！结果：" + o.toString());
            }
        };
    }

    /**
     * 创建 被观察者对象1
     */

    public void createObservableMethod1() {
        mObservable1 = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联
                if (!e.isDisposed()) {
                    e.onNext("被观察者对象1 发出第00波数据......");
                    e.onNext("被观察者对象1 发出第11波数据......");
                    e.onNext("被观察者对象1 发出第22波数据......");
                    e.onComplete();
                }
            }
        });
    }

    /**
     * 创建 观察者对象2
     */

    public void createObserverMethod2() {
        mNextConsumer2 = new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                if (null == o) {
                    return;
                }
                Log.d("TAG", "观察者对象2 onNext方法执行！！！结果：" + o.toString());
            }
        };
    }

    /**
     * 创建 被观察者对象2
     */

    public void createObservableMethod2() {
        mObservable2 = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                if (e == null) {
                    return;
                }

                //没有切断与观察者的关联
                if (!e.isDisposed()) {
                    e.onNext("被观察者对象2 发出第33波数据......");
                    e.onNext("被观察者对象2 发出第44波数据......");
                    e.onNext("被观察者对象2 发出第55波数据......");
                    e.onComplete();
                }
            }
        });
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mCompositeDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mCompositeDisposable.isDisposed());
            if (!mCompositeDisposable.isDisposed()) {//没有断开
                mCompositeDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

结果

D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第00波数据......

D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第11波数据......

D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第22波数据......



D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第33波数据......

D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第44波数据......

D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第55波数据......

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

说明

<1> 2.X版本的RxJava。普通的订阅关系(使用Observer接口创建观察者)订阅时无返回值。这种方式当单个订阅关系时，观察者接收消息后自动断开。代码结果如上。

<2> 2.X版本的RxJava。其他订阅关系(使用 Consumer对象或者Action对象)订阅时有返回值。返回值类型Disposable对象。这种方式当单个订阅关系时，观察者接收消息后自动断开。代码结果如上。

<3> 当有多个订阅关系时，可以使用CompositeDisposable对象统一管理Disposable对象。然后统一取消订阅。多个订阅关系时，关闭页面时 没有自动断开 。代码结果如上。

源码

Disposable接口源码

public interface Disposable {
    /**
     * Dispose the resource, the operation should be idempotent.
     */
    void dispose();

    /**
     * Returns true if this resource has been disposed.
     * @return true if this resource has been disposed
     */
    boolean isDisposed();
}

有两个方法断开以及是否断开。

CompositeDisposable类源码

public final class CompositeDisposable implements Disposable, DisposableContainer {
     
      ...    

}

CompositeDisposable类实现了Disposable接口。

添加Disposable对象到CompositeDisposable对象

mCompositeDisposable = new CompositeDisposable();
mCompositeDisposable.add(mDisposable1);
mCompositeDisposable.add(mDisposable2);

add方法源码

public boolean add(Disposable d) {
    ObjectHelper.requireNonNull(d, "d is null");
    if (!disposed) {
        synchronized (this) {
            if (!disposed) {
                OpenHashSet<Disposable> set = resources;
                if (set == null) {
                    set = new OpenHashSet<Disposable>();
                    resources = set;
                }
                set.add(d);
                return true;
            }
        }
    }
    d.dispose();
    return false;
}

和1.X版本的类似，判断是否断开。没断开的情况下同步方法中声明一个OpenHashSet<Disposable>集合。用来存放各个订阅关系Disposable对象。先后断开Disposable对象。

断开订阅

if (!mCompositeDisposable.isDisposed()) {//没有断开
      mCompositeDisposable.dispose();//断开    
}

dispose方法源码

public void dispose() {
    if (disposed) {
        return;
    }
    OpenHashSet<Disposable> set;
    synchronized (this) {
        if (disposed) {
            return;
        }
        disposed = true;
        set = resources;
        resources = null;
    }

    dispose(set);
}

dispose()方法源码

void dispose(OpenHashSet<Disposable> set) {
    if (set == null) {
        return;
    }
    List<Throwable> errors = null;
    Object[] array = set.keys();
    for (Object o : array) {
        if (o instanceof Disposable) {
            try {
                ((Disposable) o).dispose();
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (errors == null) {
                    errors = new ArrayList<Throwable>();
                }
                errors.add(ex);
            }
        }
    }
    if (errors != null) {
        if (errors.size() == 1) {
            throw ExceptionHelper.wrapOrThrow(errors.get(0));
        }
        throw new CompositeException(errors);
    }
}

即此方法的核心(忽略catch代码块)就是遍历OpenHashSet<Disposable>集合中存放的单个Disposable对象。然后调用单个Disposable对象的断开的方法。

总结：CompositeDisposable对象统一管理Disposable对象。大概的原理就是先将Disposable对象存放在CompositeDisposable对象的Set集合中。统一取消订阅时。再遍历CompositeDisposable对象的Set集合。然后统一取消订阅。

四.2.X版本创建被观察者的其他操作符

1.create

简介

同上

代码

同上

结果

同上

2.Just

简介

发送单个数值，和1.X版本一样，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。

代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;
    private Disposable mDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                mDisposable = d;
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.just("1", 2, "张三", 6598);
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

结果

D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

D/TAG: 观察者onNext方法执行！！！结果：1

D/TAG: 观察者onNext方法执行！！！结果：2

D/TAG: 观察者onNext方法执行！！！结果：张三

D/TAG: 观察者onNext方法执行！！！结果：6598

D/TAG: 观察者onComplete方法执行！！！

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

3.fromArray

简介

发送数组类型的数据，相当于1.X的From方法。

代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;
    private Disposable mDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                mDisposable = d;
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        String items[] = {"1", "2", "张三", "6598", "我是数组"};
        mObservable = Observable.fromArray(items);
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

结果

D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

D/TAG: 观察者onNext方法执行！！！结果：1

D/TAG: 观察者onNext方法执行！！！结果：2

D/TAG: 观察者onNext方法执行！！！结果：张三

D/TAG: 观察者onNext方法执行！！！结果：6598

D/TAG: 观察者onNext方法执行！！！结果：我是数组

D/TAG: 观察者onComplete方法执行！！！

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

4.fromIterable

简介

发送集合List数据。1.X中无此类型的操作符。

代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import java.util.ArrayList;
import java.util.List;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;
    private Disposable mDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                mDisposable = d;
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("张三");
        list.add("6598");
        list.add("我是集合");
        mObservable = Observable.fromIterable(list);
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

结果

D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

D/TAG: 观察者onNext方法执行！！！结果：1

D/TAG: 观察者onNext方法执行！！！结果：2

D/TAG: 观察者onNext方法执行！！！结果：张三

D/TAG: 观察者onNext方法执行！！！结果：6598

D/TAG: 观察者onNext方法执行！！！结果：我是集合

D/TAG: 观察者onComplete方法执行！！！

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

5.timer

简介

快速创建1个被观察者对象。延迟指定时间后，发送Long类型数据。

代码

package com.example.rxjava20;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;
    private Disposable mDisposable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                mDisposable = d;
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.timer(2, TimeUnit.SECONDS);
        Log.d("TAG", "被观察者对象发送数据");
    }

    /**
     * onDestroy方法
     */

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (null != mDisposable) {
            Log.d("TAG", "onDestroy方法 执行时是否断开----：" + mDisposable.isDisposed());
            if (!mDisposable.isDisposed()) {//没有断开
                mDisposable.dispose();//断开
                Log.d("TAG", "onDestroy方法 断开订阅");
            }
        }
    }

}

说明

Observable.timer(2, TimeUnit.SECONDS);

public static Observable<Long> timer(long delay, TimeUnit unit) {}

参数1：延时时间延时XX执行。

参数2：延时单位。

SECONDS ：秒

MINUTES：分钟

HOURS：小时

...

结果

56:56.872 8512-8512/com.example.mydemo D/TAG: 被观察者对象发送数据

56:56.872 8512-8512/com.example.mydemo D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

56:58.874 8512-8548/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：0

56:58.874 8512-8548/com.example.mydemo D/TAG: 观察者onComplete方法执行！！！

关闭页面

D/TAG: onDestroy方法 执行时是否断开----：false

D/TAG: onDestroy方法 断开订阅

6.interval

简介

快速创建1个被观察者对象。每隔指定时间就发送数据。应用场景：间隔X时间请求一次接口。

代码

package com.example.mydemo.rxjava;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import com.example.mydemo.R;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxJavaActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rxjava);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.interval(3, 1, TimeUnit.SECONDS);
        Log.d("TAG", "被观察者对象发送数据");
    }

}

说明

Observable.interval(3, 1, TimeUnit.SECONDS);

参数1：第1次延迟时间。

参数2：间隔时间。

参数3：时间单位。

SECONDS ：秒

MINUTES：分钟

HOURS：小时

...

结果退出Activity 还是会继续发送数据。

04:01.223 8986-8986/com.example.mydemo D/TAG: 被观察者对象发送数据

04:01.224 8986-8986/com.example.mydemo D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

04:04.227 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：0

04:05.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：1

04:06.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：2

04:07.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：3

04:08.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：4

04:09.227 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：5

04:10.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：6

04:11.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：7

04:12.225 8986-9415/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：8

7.intervalRange

简介

快速创建1个被观察者对象。每隔指定时间就发送数据。可指定发送的数据的数量。interval方法的加强版。应用场景：间隔多长时间请求一次接口，一共定义请求几次。

代码

package com.example.mydemo.rxjava;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import com.example.mydemo.R;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxJavaActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rxjava);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.intervalRange(5, 10, 2, 1, TimeUnit.SECONDS);
        Log.d("TAG", "被观察者对象发送数据");
    }

}

说明

Observable.intervalRange(5, 10, 2, 1, TimeUnit.SECONDS);

参数1：开始位置。

参数2：发送数量。

参数3：第1次延迟时间。

参数4：间隔时间。

参数5：时间单位。

SECONDS ：秒

MINUTES：分钟

HOURS：小时

...

结果发送onNext数量为10

13:24.844 9901-9901/com.example.mydemo D/TAG: 被观察者对象发送数据

13:24.845 9901-9901/com.example.mydemo D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

13:26.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：5

13:27.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：6

13:28.849 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：7

13:29.847 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：8

13:30.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：9

13:31.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：10

13:32.848 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：11

13:33.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：12

13:34.848 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：13

13:35.846 9901-10541/com.example.mydemo D/TAG: 观察者onNext方法执行！！！结果：14

13:35.847 9901-10541/com.example.mydemo D/TAG: 观察者onComplete方法执行！！！

8.range

简介

快速创建1个被观察者对象。连续发送可指定范围的数据。

代码

package com.example.mydemo.rxjava;

import android.os.Bundle;
import android.util.Log;

import androidx.appcompat.app.AppCompatActivity;

import com.example.mydemo.R;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxJavaActivity extends AppCompatActivity {

    private Observer mObserver = null;
    private Observable mObservable = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rxjava);

        createObserverMethod();//创建观察者对象
        createObservableMethod();//创建被观察者对象
        if (null != mObserver && null != mObservable) {
            mObservable.subscribe(mObserver);//完成订阅
        }
    }

    /**
     * 创建 观察者对象
     */

    public void createObserverMethod() {
        mObserver = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                if (null == d) {
                    return;
                }
                Log.d("TAG", "观察者onSubscribe方法执行！！！d.isDisposed()" + d.isDisposed());
            }

            @Override
            public void onNext(Object value) {
                if (null == value) {
                    return;
                }
                Log.d("TAG", "观察者onNext方法执行！！！结果：" + value.toString());
            }

            @Override
            public void onError(Throwable e) {
                Log.d("TAG", "观察者onError方法执行！！！");
            }

            @Override
            public void onComplete() {
                Log.d("TAG", "观察者onComplete方法执行！！！");
            }
        };
    }

    /**
     * 创建 被观察者对象
     */

    public void createObservableMethod() {
        mObservable = Observable.range(2, 5);
        Log.d("TAG", "被观察者对象发送数据");
    }

}

说明

Observable.range(2, 5);

参数1：开始位置。

参数2：数据量个数。

结果 2开始 5条数据

D/TAG: 被观察者对象发送数据

D/TAG: 观察者onSubscribe方法执行！！！d.isDisposed()false

D/TAG: 观察者onNext方法执行！！！结果：2

D/TAG: 观察者onNext方法执行！！！结果：3

D/TAG: 观察者onNext方法执行！！！结果：4

D/TAG: 观察者onNext方法执行！！！结果：5

D/TAG: 观察者onNext方法执行！！！结果：6

D/TAG: 观察者onComplete方法执行！！！

注意：上述的快速创建被观察者的方法，有一定的应用场景。

<1> interval：间隔X时间请求一次接口。

<2> intervalRange：间隔多长时间请求一次接口，一共定义请求几次。

五.总结

2.X版本的RxJava使用总结

<1> 创建观察者只有Observer接口一种实现方式。详解上看。

<2> 创建被观察者可以使用很多的操作符，不只局限于create，just，fromArray，timer 四种操作符。详解上看。

<3> 观察者和被观察者发生订阅关系有几个重载方法。使用某一个重载的方法可以单独使用onNext对象。也可以onNext对象+onComplete对象+onError对象结合使用。相当于使用Observer接口创建观察者详解上看。

<4> 也是最终要的。2.X版本的RxJava。

(1) 默认订阅关系无返回值，订阅关系是在观察者的onSubscribe方法中返回的Disposable对象。

(2) 使用某一个重载的方法可以单独使用onNext对象或者其他组合方式实现订阅关系有返回值Disposable对象。

(3) 以上两种情况下，如果使用create操作符创建被观察者。无论是onSubscribe方法中返回的Disposable对象还是订阅关系时返回的Disposable对象。订阅关系都会自动断开，不需要手动维护。

如果使用其他的操作符创建被观察者(比如Just操作符) 无论是onSubscribe方法中返回的Disposable对象还是订阅关系时返回的Disposable对象。订阅关系都会不会自动断开，需要手动维护。

(4) 多个订阅关系时，没有自动断开。

(5) 具体详解如上。

jianning-wu

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
RxJava详解(基于2.X版本)

1.java的数据类型8 种类型表示范围如下：byte：8位，最大存储数据量是256，存放的数据范围是-128~127之间。short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。long：64位，最大数据存储容量是2的64...
复制链接

扫一扫