RxJava2初探

RxJava2之观察者模式

观察者(Observer)模式初探

---

是对象的行为模式，即发布-订阅者(Publish/Subscribe)模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主体对象在状态上发生变化时，会通知所有观察者对象，能使他们自动更新自己。

角色

• 抽象主题(Subject)

  存在形式：**抽象类（推荐）**或者接口

  增加和删除观察者对象，将所有对观察者的引用保存在集合里(如ArrayList)

• 具体主题(ConcreteSubject)

  将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有登记过的观察者发出通知，具体主题角色又叫做被观察者(ConcreteObserverable)角色

• 抽象观察者(Observer)

  为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫更新接口。

• 具体观察者(ConcreteObserver)

  实现抽象观察者的更新接口，以使得本身状态的更新

RxJava2之基本使用

一个在Java VM上使用可观测的序列来组成异步的，基于事件的程序的库

• 特点：异步，简单，强大

RxJava： https://github.com/ReactiveX/RxJava

RxAndroid: https://github.com/ReactiveX/RxAndroid

添加依赖：

//RxJava
implementation "io.reactivex.rxjava2:rxjava:2.x.y"
//RxAndroid
implementation 'io.reactivex.rxjava2:rxandroid:2.x.y'

观察者模式

1. Observable： 被观察者（主题Subject）
2. Observer/Subscriber： 观察者
3. Subscribe ：订阅

• Observable和Observer通过subscribe()方法实现订阅关系

使用三部曲

1.创建Observable

• onNext()
• onError()
• onComplete()

/**
 * 创建被观察者
 *
 * @return
 */
public Observable<String> getObservable() {
    return Observable.create(new ObservableOnSubscribe<String>() {
        //ObservableEmitter为事件发射器
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            e.onNext("出去玩");
            e.onNext("酒吧");
            e.onError(new Throwable());
            e.onComplete();
        }
    });
}

简洁的写法:

public Observable<String> getObservable() {
    //其实调用的是Observable.fromArray("test", "出去玩", "酒吧");
    return Observable.just("test", "出去玩", "酒吧");
}

2.创建Observer

• onNext()
• onError()
• onComplete() 与onError()互斥

/**
 * 创建观察者
 *
 * @return
 */
public Observer<String> getObserver() {
    return new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
			//Disposable,可保存，后续onNext()中丢弃关系
            //Disposable可用于取消订阅
            Log.d(TAG, "onSubscribe");
        }

        @Override
        public void onNext(String s) {
            Log.d(TAG, "onNext");
        }

        @Override
        public void onError(Throwable e) {
            Log.d(TAG, "onError");
        }

        @Override
        public void onComplete() {
            Log.d(TAG, "onComplete");
        }
    };

}

3.实现订阅

• observable.subscribe(observer);

Observable<String> observable = getObservable();
Observer<String> observer = getObserver();
//订阅
observable.subscribe(observer);

注：更简洁的写法

observable.subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {

        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception {

        }
    }, new Action() {
        @Override
        public void run() throws Exception {

        }
    });