RxJava与MVP结构的使用

MVP

有一种跟MVP相类似的开发结构MVC，该结构由三层组成：

M 模型层

该层也叫实体层，是存放数据的部分

V 视图层

该层用来构建UI界面

C 控制器层

该层对视图层和实体层起到连接作用

eg：

一个简单的登录层序，登录界面的构建由V层实现，数据存放（包括对数据库的操作）由M层实现，而C层功能为：当用户输入账号密码，C层便会从V层拿到用户数据后再从M层拿到原有数据进行比对，若一致再通知V层进行登录成功的UI响应。

在Android开发中，V层常再Activity/Fragment中完成，但逻辑事务处理大多也在Activity/Fragment中实现，为此V和C层就难免混在一起，逻辑处理与视图构建耦合度较高。

而MVP模式可以较为有效地解决这个问题：

MVP结构层次：

M 模型层

与MVC一样，也是存放数据的部分

V 视图层

该层也用来构建UI界面，但不同的是在该层MVP结构会通过定义一个用来定义所有视图层所要用到的方法，然后由Activity/Fragment实现该接口

P Presenter

类似于MVC中的C层，该层由定义逻辑方法的接口和实现该接口的类组成，在实现接口的类中带有V接口的引用，可以对视图进行操作，而实现接口的引用由Actiity/Fragment携有，可可在View接口的重写方法中调用Presenter相应的方法

结构图如下：

MVP结构的优点

1. 将视图逻辑和业务逻辑从Activity/Fragment分离了出来，降低了耦合，便于维护：
   由此也避免在异步处理业务逻辑时持续持有Activity引用导致OOM

2. 将方法定义为接口，从而让代码更加简洁清晰

RxJava

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

参照于：

Android Rxjava：这是一篇 清晰 & 易懂的Rxjava 入门教程

RxJava是一个基于事件流，实现异步操作的库

其作用类似于Android原生的AsyncTask和Handle

RxJava的处理过程是以观察者模式为设计模式通过链式调用由观察者（Observer）对被观察者（Observable）的响应事件（Event）进行监听处理，观察者与被观察者通过订阅（Subscribe）进行连接

使用步骤

创建被观察者，生成事件

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
  @Override
  public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onNext(3);
    emitter.onComplete();
    }
});

通过Observable的create方法创建被观察者对象，在重写的subscribe方法中定义要发送的事件

除此方法外，还可以通过以下两种方式创建：

//方式1
Observable observable = Observable.just(1, 2, 3);
int[] is = {1, 2, 3};
//方式2
Observable observable = Observable.from(is);

以上两种方式都会依次调用以下方法：

onNext(1);
onNext(2);
onNext(3);
onCompleted();

创建观察者，响应事件

//方式1
Observer<Integer> observer = new Observer<Integer>() {
    //接受事件前调用
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "onSubscribe");
    }

    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "onNext：" + value);
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "onError");
    }
    @Override
    public void onComplete() {
        Log.d(TAG, "onComplete");
    }
};
//方式2
Subscriber<String> subscriber = new Subscriber<Integer>() {
    @Override
    public void onSubscribe(Subscription s) {
        Log.d(TAG, "onSubscribe");
    }
    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "onNext: " + value);
    }

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

Observer与Subscriber不同之处在于Subscriber是Observer的扩展，当调用subscribe进行订阅时，Observer仍然会被转换成Subscriber

Subscriber增加了以下两个方法：

onStart()

unsubscribe()

当不使用Subscriber对象时，可通过isUnsubscribed()方法判断状态然后调用unsubscribe()方法对该对象进行释放

进行订阅，连接观察者与被观察者

observable.subscribe(observer);
//observable.subscribe(subscriber);

链式调用

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "开始采用subscribe连接");
    }
    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "对Next事件"+ value +"作出响应"  );
    }
    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "对Error事件作出响应");
    }
    @Override
    public void onComplete() {
        Log.d(TAG, "对Complete事件作出响应");
    }
  });

可通过Disposable对象d的dispose方法切断观察者与被观察者的连接：

d.dispose();