RxJava+Retrofit+MVVM的封装

RxJava+Retrofit+MVVM的封装之路(一) 
注：其中有一些代码是参考网上其他博主的

  现在网上有很多关于RxJava+Retrofit的文章，于是博主就想将其与MVVM的设计框架结合起来，来试着写一个适用于基本开发的框架，当然，博主也是在学习的过程中，如果出现错误，请指正并探讨.

  在这篇文章中，主要讲解的是如何对RxJava+Retrofit（简称RR）进行第一次简单的封装处理，我们在每次使用RR时都需要去初始化，本篇文章就是针对这种情况，暂时还未涉及到关于MVVM设计框架的思想。
  第一步，去创建一个单例模式来初始化RR

 public class ApiInstance implements ConstantUtil{

    public static final String TAG="ApiInstance";
    private volatile static ApiInstance INSTANCE;
    private ApiService apiService;
    //构造方法私有
    private ApiInstance() {
    //手动创建一个OkHttpClient并设置超时时间
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

    apiService = new Retrofit.Builder().baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create(new Gson()))
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .build()
            .create(ApiService.class);
}
//获取单例
public static ApiInstance getInstance() {
    if (INSTANCE == null) {
        synchronized (ApiInstance.class) {
            if (INSTANCE == null) {
                INSTANCE = new ApiInstance();
            }
        }
    }
    return INSTANCE;
}

public ApiService getApiService() {
    return apiService;
}

} 
第二步：创建service

 @GET
 Observable<MainModel> getMainApi(@Url String url);

第三步：创建BaseActivity，也就是在这个类里，我们去调用已经初始 化的RR

public class BaseActivity extends FragmentActivity {
protected BaseActivity mActivity;
public ApiService apiService;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mActivity=this;
    apiService=init();
}

private ApiService init() {
    if (EmptyUtils.isEmpty(apiService)){
        apiService=   ApiInstance.getInstance().getApiService();
    }
    return apiService;
}

@Override
protected void onDestroy() {
    super.onDestroy();
}

} 
在其中有一个判断service是否为null的操作，以避免重复初始化 
好了，到了这里有关初始化RR的内容基本结束，接下来就看一下我们 怎么调用了 
第四步：创建MainActivity

public class MainActivity extends BaseActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    apiService.getMainApi("url")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .doOnNext(new Action1<MainModel>() {
                @Override
                public void call(MainModel mainModel) {
                  Log.v("ideaMessage",mainModel.toString());
                }
            }).flatMap(new Func1<MainModel, Observable<ItemsModel>>() {
        @Override
        public Observable<ItemsModel> call(MainModel mainModel) {
            return Observable.from(mainModel.getPositions());
        }
    }).subscribe(new Subscriber<ItemsModel>() {
        @Override
        public void onCompleted() {
            Log.v("ideaMessage","onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            Log.v("ideaMessage","onError :"+e.toString());
        }

        @Override
        public void onNext(ItemsModel itemsModel) {
            Log.v("ideaMessage","onNext");
            Log.v("ideaMessage",itemsModel.toString());
        }
    });
}

@Override
protected void onDestroy() {
    super.onDestroy();
}

}

我们可以看到，在请求网络时，只需要使用apiService就可以了，只要是继承BaseActivity的类就可以来进行网络操作，当然，这样也会有一些局限性，不过，这个问题不难解决，你可以写一个公共类，将BaseActivity里的操作移到公共类中，然后通过静态变量的方式去调用apiService，就可以了，这么说可能有一下抽象，看一下公共类的代码吧

public class IdeaService {
private static IdeaService ideaService;
public ApiService apiService;


public void init(){
    apiService=ApiInstance.getInstance().getApiService();
}

public static IdeaService getIdeaService() {
    if (EmptyUtils.isEmpty(ideaService)){
        ideaService=new IdeaService();
    }
    return ideaService;
}

public ApiService getApiService() {
    return apiService;
}

} 
然后调用就变成了 
IdeaService.getIdeaService().getApiService().getMainApi(“url”)

好了，到此为止，基本第一次封装初始化就已经搞定了，下篇文章将提供有关封装网络请求的代码。 
备注 : public static final int DEFAULT_TIMEOUT=10000; 静态变量的值，有问题欢迎指正