Android MVP+RxJava+Retrofit 入门封装

为什么要在Android开发中使用MVP

个人理解是这样的,并不是mvc模式不好,做过javaweb开发的小伙伴都知道mvc也是为了更好的解耦,但是因为在android开发中,有Activity这样的组件以及Fragment这样的碎片会导致Activity中的代码太臃肿,因为Activity中既要写逻辑(C层)也要写数据获取(M层),所以在一个类中C层和M层的代码都在一起了

如何能够快速掌握MVP设计模式
网上写MVP 的例子太多了 但是更推荐的是google官方的 todo-mvp 这个例子,然后就是要自己总结和理解
1.MVP的目的? 更好的解耦 让Activity变成View层(Activity中只有View初始化和变化的逻辑)
2.Presenter的作用? 拥有View层和Module的实例 (View层无法直接访问Module层) 

3.Module层的写法? 利用接口将自己封装的网络请求框架请求成功后的数据进行返回

下面纯是一个小例子,通过Retrofit网络请求Gank接口 并解析显示在textview上,例子虽小,但是五脏俱全,
首先看一下结构



开始例子
[b]1.导入需要的依赖以及在清单文件添加网络权限:[/b]

//rxjava
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
//retrofit
compile 'com.squareup.retrofit2:retrofit:2.2.0'
//retrofit支持Gson
compile 'com.squareup.retrofit2:converter-gson:2.2.0'
//retrofit支持rx依赖
compile 'com.squareup.retrofit2:adapter-rxjava2:2.2.0'

2.完成RetrofitApi请求类public interface Api {
@GET("data/Android/10/1")
Observable<GankBean> getGankBean();
}
3.封装一个Retrofit的网络请求封装类public class RetrofitTool {
public static RetrofitTool instance;
private Retrofit retrofit;
private final Api api;

public Api getApi() {
return api;
}

private RetrofitTool() {
//初始化Retrofit
retrofit = new Retrofit.Builder().baseUrl("http://gank.io/api/")
//给Retrofit添加Gson解析功能
.addConverterFactory(GsonConverterFactory.create())
//给Retrofit添加Rxjava功能
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
//初始化Retrofit的Api接口
api = retrofit.create(Api.class);
}

//线程锁单例
public static RetrofitTool getInstance() {
if (instance == null) {
synchronized (RetrofitTool.class) {
if (instance == null) {
instance = new RetrofitTool();
}
}
}
return instance;
}
}准备工作完成了,个人认为应该先写Presenter层的接口
4.编写Presenter层的接口public interface MainActivityPresenter {
//这是留给View层去调用Module层请求的方法
void getGankBean();

//下面四个方法是P层对Module层请求状态的监听(请求成功,开始请求,请求结束,请求失败)
void getGankBeansuccess(GankBean gankBean);
void getGankBeanStart();
void getGankBeanFailed();
void getGankBeanFinish();
}5.先不创建Presenter的实现类 接着创建Module层的接口public interface GankBeanModule {
//把P层的接口作为方
4000
法参数传递进来(为了进度监听) 这个方法顾名思义就是请求GankBean数据
void getGankBean(MainActivityPresenter presenter);
}6.创建Module层的实现类(在实现类使用Retrofit进行网络请求同时利用刚刚传进来Presenter进行状态监听)public class GankBeanModuleImpl implements GankBeanModule {
@Override
public void getGankBean(final MainActivityPresenter presenter) {
//开始请求
presenter.getGankBeanStart();
//Retrofit开始请求
RetrofitTool.getInstance().getApi()
.getGankBean()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<GankBean>() {
@Override
public void accept(GankBean gankBean) throws Exception {
//请求成功并调用P层的监听方法
presenter.getGankBeansuccess(gankBean);
presenter.getGankBeanFinish();
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
//请求失败的监听调用
presenter.getGankBeanFailed();
throwable.printStackTrace();
}
});
}
}7.对View层的接口进行编写
也比较好理解,声明了四种状态,在网络请求的时候在不同的状态中显示不同的ui效果,最好在成功的方法中把实体类作为参数传递public interface MainActivityView {
void success(GankBean gankBean);
void onStartGetData();
void onFailedGetData();
void onFinishGetData();
}8.对Presenter的实现类进行编写public class MainActivityPresenterImpl implements MainActivityPresenter {
private MainActivityView view;
private GankBeanModule gankBeanModule;

public MainActivityPresenterImpl(MainActivityView view) {
//在构造方法中初始化View层和Module层的对象
this.view = view;
gankBeanModule = new GankBeanModuleImpl();
}

@Override
public void getGankBean() {
gankBeanModule.getGankBean(this);
}

//module层请求的回调并调用View层相对应状态的方法
@Override
public void getGankBeansuccess(GankBean gankBean) {
view.success(gankBean);
}

@Override
public void getGankBeanStart() {
view.onStartGetData();
}

@Override
public void getGankBeanFailed() {
view.onFailedGetData();
}

@Override
public void getGankBeanFinish() {
view.onFinishGetData();
}

}
9.在Activity(View的实现类)中编写public class MainActivity extends AppCompatActivity implements MainActivityView {

public TextView tv1;
public MainActivityPresenterImpl presenter;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv1 = (TextView) findViewById(R.id.tv1);
//获取P层实例并把view层传给P层
presenter = new MainActivityPresenterImpl(this);
//调用P层请求方法
presenter.getGankBean();

}

@Override
public void success(GankBean gankBean) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i <gankBean.getResults().size() ; i++) {
sb.append(gankBean.getResults().get(i).getUrl() + "\n");
}
tv1.setText(sb);
}

@Override
public void onStartGetData() {
tv1.setText("正在加载");
}

@Override
public void onFailedGetData() {
tv1.setText("加载失败");
}

@Override
public void onFinishGetData() {
Toast.makeText(this, "加载完成", Toast.LENGTH_SHORT).show();
}
}

兜兜转转一大圈之后,module层的数据终于通过 
1.view层调用p层中的getGankBean()方法 

2.在p层中的getGankBean()方法内p层会调用module层的[b]getGankBean()的方法进行网络请求[/b]
[b]3.请求成功后再利用p层在m层的监听方法把数据回调到p层[/b]
[b]4.然后在p层的回调方法中调用view层的监听方法把数据回调到Activity中[/b]

[b]深刻理解之后就更能体会p是桥梁了[/b]