基于mvp架构的retrofit+rxandroid的网络访问

1.如果大家还不是很了解retrofit+rxandroid的话，建议去github去看一下获取搜一下关于这方面的资料，废话不多说我们来开始了解一下基于mvp的retrofit的使用

2.首先看一下整体的结构图

3.由图可以看出这种写法完全摒弃了view，model和presenter层的复杂性，分别有一个工厂类来代替了，大家也可以根据自己的需求来修改，那么问题来，我们如何调用和使用呢，废话不多说，直接上代码：

1，看mode层到底干了一些什么：

public class ModeFactory {
    public static ModeFactory business;
    public static ModeFactory getInstance(){
        if (business == null) {
            business = new ModeFactory();
        }
        return business;
    }


    public  void radioModel(CallBackListener<List<RadiosListEntity>> backListener) {
        RetrofitHelper.getInstance().getService().getRadiosList()
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(NetWorkDao.getInstance().createSubscriber(backListener));
    }


    public void songModel(String mode,CallBackListener<List<SongsListEntity>> backListener) {
        RetrofitHelper.getInstance().getService().getSongsList(mode)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(NetWorkDao.getInstance().createSubscriber(backListener));
    }

    public void radioListModel(Object o,CallBackListener<PlayRadioListEntity> backListener) {
        RetrofitHelper.getInstance().getService().reqRadiosList((PlayRadioReq) o)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(NetWorkDao.getInstance().createSubscriber(backListener));
    }




}

是不是少些了很多model接口和实现类，直接写一个modelfactory，然后用单例的方式获取，然后在presenter中调用，然后在subscibe中传入一个你创建的订阅者，同过订阅者把回调的接口传入，这样就完成了一个model体的实现。同时也把需要的传入的参数传入进来。presenter工厂中同样需要，那我们继续，看一下如何创建订阅者的，直接上代码：

/**
 * Created by cuieney on 16/5/19.
 */
public class NetWorkDao<T> {
    public  static NetWorkDao netWorkDao;

    public NetWorkDao() {
    }

    public synchronized static NetWorkDao getInstance(){
        if (netWorkDao == null) {
            netWorkDao  = new NetWorkDao();
        }
        return netWorkDao;
    }

    public Subscriber createSubscriber(final CallBackListener<? super T> callBackListener){
        Subscriber mSubscriber = new Subscriber<T>(){

            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                callBackListener.onFailed(e);
            }

            @Override
            public void onNext(T t) {
                callBackListener.onSuccess(t);
            }
        };

        return mSubscriber;
    }

}

可以看到在我们创建订阅者的时候，把要回调的接口已经传入，通过model工厂完成了callbacklistener的监听，然后在订阅者这的方法回调中来做监听。

public interface CallBackListener<T> {
    void onSuccess(T t);
    void onFailed(Throwable throwable);
}

callbacklistener也就是一个简单的回接口的实现，重点来了，我们在presenter中如何使用工厂中的model呢,还是那句话直接上代码。本人语言表达能力比较差

public class PresenterFactory {
    public static PresenterFactory business;
    public Object parameters;

    public static PresenterFactory getInstance(){
        if (business == null) {
            business = new PresenterFactory();
        }
        return business;
    }

    public PresenterFactory setParameters(Object objects){
        parameters = objects;
        return business;
    }

    public PresenterFactory setPost(Object... objects){

        return business;
    };



    public void getRadioListPresenter(final ViewFactory<PlayRadioListEntity> radioListView){
        ModeFactory.getInstance().radioListBus(parameters, new CallBackListener<PlayRadioListEntity>() {
            @Override
            public void onSuccess(PlayRadioListEntity playRadioListEntity) {
                radioListView.onSuccess(playRadioListEntity);
            }

            @Override
            public void onFailed(Throwable throwable) {
                radioListView.onFailed(throwable);
            }
        });

    }

    public void getRadioPresenter(final ViewFactory<List<RadiosListEntity>> radioView){
       ModeFactory.getInstance().radioBus(new CallBackListener<List<RadiosListEntity>>() {
           @Override
           public void onSuccess(List<RadiosListEntity> radiosListEntities) {
                radioView.onSuccess(radiosListEntities);
           }

           @Override
           public void onFailed(Throwable throwable) {
                radioView.onFailed(throwable);
           }
       });
    }

    public void getSongPresenter(final ViewFactory<List<SongsListEntity>> songView){
        ModeFactory.getInstance().songBus("hot", new CallBackListener<List<SongsListEntity>>() {
            @Override
            public void onSuccess(List<SongsListEntity> songsListEntities) {
                songView.onSuccess(songsListEntities);
            }

            @Override
            public void onFailed(Throwable throwable) {
                songView.onFailed(throwable);
            }
        });
    }

由上面的代码可以看出，我们可以在presenter工厂中做一件事情，当我们的retrofit服务需要传入参数的时候我们可以这样调用，先把参数传入，然后在获取相应的presenter，我这里没有做post请求参数的处理，制作了单个参数的处理，大家可以根据自己的需求自己写入相应的方法。通过实例化presenter工厂类，然后再调用相应的presenter，，由于viewfactory也只有一个，所以我们会在presenter中做许多事情，把view层的代码简化了。那么我们来看一下viewfactory如何编写的呢

/**
 * Created by cuieney on 16/5/19.
 */
public interface ViewFactory<T> {
    void onSuccess(T t);
    void onFailed(Throwable throwable);
}

简单吧和callback listener是一样的，只不过换了名称，这样我们在presenter中就可以随意的参入参数进行调用了。那么我们来看一下，如何在调用的地方如何使用呢！看了这么多的代码，大家应该也明白了一些东西，可以直接通过presenter工厂类的单例直接获取，省了不少麻烦啊

PresenterFactory.getInstance()
        .setParameters(new PlayRadioReq("", "", true))
        .getRadioListPresenter(this);

是不是很简单，一句代码搞定了网路请求，同事降低了view和model层的耦合性。小的工程确实看起来起不了多大的作用，而且还增加了代码量，但是对于大的项目和单元测试方面，确实起到了不少的作用。废话不多说，希望大家可以下学到一点东西。竟然在上班时间写这东西，哈哈不过老板不在