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上,例子虽小,但是五脏俱全,

首先看一下结构

开始例子

1.导入需要的依赖以及在清单文件添加网络权限:

    //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层的接口作为方法参数传递进来(为了进度监听) 这个方法顾名思义就是请求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层的getGankBean()的方法进行网络请求

3.请求成功后再利用p层在m层的监听方法把数据回调到p层

4.然后在p层的回调方法中调用view层的监听方法把数据回调到Activity中

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