Retrofit+Rxjava+MVP封装的网络请求框架

网络请求所需要的依赖

    //添加retrofit依赖
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    //添加gson转换器的依赖
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'

    compile "io.reactivex.rxjava2:rxjava:2.1.10"

    compile 'io.reactivex.rxjava2:rxandroid:2.0.2'

    //注意 rxjava2是2.0的 不加2表示的是1.0
    compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

Model接口包括可以实现的两个方法

public interface BaseModel<T> {

    void getDataFromNet(String url, Map<String,String> map,    IBaseRequest<T> iBaseRequest);

    void onUnsubscribe();
}

Model开始处理数据的类

public class HomeModel implements BaseModel<HomeBean> {

    /**
     * CompositeDisposable Rxjava2.0 出现的方法
     * add 添加到容器中   clear 解除订阅
     */
    private CompositeDisposable compositeDisposable;

    public HomeModel() {
        compositeDisposable = new CompositeDisposable();
    }

    @Override
    public void getDataFromNet(String url, Map<String, String> map, final IBaseRequest<HomeBean> iBaseRequest) {

        RetrofitUtil.getInstance(IntegratedUrl.HOBASE_Url).createService(ApiService.class).doGet(url,map)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<ResponseBody>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        compositeDisposable.add(d);
                    }

                    @Override
                    public void onNext(ResponseBody responseBody) {
                        try {
                            String json = responseBody.string();

                            HomeBean homeBean = new Gson().fromJson(json, HomeBean.class);
                            iBaseRequest.requestSuccess(homeBean);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        iBaseRequest.requestError(e);
                    }

                    @Override
                    public void onComplete() {
                        iBaseRequest.requestComplete();
                    }
                });
    }

    @Override
    public void onUnsubscribe() {
        compositeDisposable.clear();
    }

}

Presenter的一个实体类可以被继承

public class BasePresenter<V extends IBaseResponse,T> implements IBaseRequest<T> {

    private IBaseResponse iBaseResponse;

    public BasePresenter(V view) {
        this.iBaseResponse = view;
    }

    @Override
    public void requestError(Throwable throwable) {
        iBaseResponse.loadDataError(throwable);
    }

    @Override
    public void requestComplete() {

    }

    @Override
    public void requestSuccess(T callBack) {
        iBaseResponse.loadDataSuccess(callBack);
    }
}

Presenter中负责处理接收model传递的数据

public class HomePresenter extends BasePresenter<HomeView,HomeBean> implements Ipresenter {

    private HomeModel homeModel;

    public HomePresenter(HomeView view) {
        super(view);
        homeModel = new HomeModel();
    }

    @Override
    public void getDataFromNet(String url, Map<String, String> map) {
        homeModel.getDataFromNet(url,map,this);
    }

    @Override
    public void onUnsubscribe() {
        homeModel.onUnsubscribe();
    }
}

请求的最大的接口

public interface IBaseRequest<T> {

    /**
     * @descriptoin 请求异常
     * @author  dc
     * @param throwable 异常类型
     * @date 2017/2/16 11:34
     */
    void requestError(Throwable throwable);

    /**
     * @descriptoin 请求完成
     * @author  dc
     * @date 2017/2/16 11:35
     */
    void requestComplete();

    /**
     * @descriptoin 请求成功
     * @author  dc
     * @param callBack 根据业务返回相应的数据
     * @date 2017/2/16 11:35
     */
    void requestSuccess(T callBack);
}

响应的最大接口

public interface IBaseResponse<T> {

    /**
     * @descriptoin  请求数据成功
     * @author   dc
     * @param tData 数据类型
     * @date 2017/2/16 11:01
     */
    void loadDataSuccess(T tData);

    /**
     * @descriptoin  请求数据错误
     * @author   dc
     * @param throwable 异常类型
     * @date 2017/2/16 11:01
     */
    void loadDataError(Throwable throwable);
}

Presenter的接口包括两个方法

public interface Ipresenter {

    void getDataFromNet(String url, Map<String,String> map);

    void onUnsubscribe();
}

需要被Presenter类继承的View接口

public interface HomeView extends IBaseResponse<HomeBean> {
}

ApiService请求方法

public interface ApiService {

    /**
     * 坑点:--------------路径的字符被转义
     *
     */
    @GET("{url}")
    Observable<ResponseBody> doGet(@Path(value = "url",encoded = true) String url, @QueryMap Map<String,String> map);

    @FormUrlEncoded
    @POST("{url}")
    Observable<ResponseBody> doPost(@Path(value = "url",encoded = true) String url, @FieldMap Map<String,String> map);
}

RetrofitUtil请求工具

public class RetrofitUtil {

    private static RetrofitUtil retrofitUtil = null;
    private Retrofit retrofit;

    private RetrofitUtil(){

    }

    private RetrofitUtil(String baseUrl){
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                //.addNetworkInterceptor()//网络拦截器
                .addInterceptor(new CommonParamsInterceptor())//拦截器
                //.connectTimeout(3000)//连接超时
                .build();

        //创建retrofit
        retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())//添加转化器
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//设置支持rxjava 注意是24
                .build();

    }

    /**
     * 单例模式
     * @return
     */
    public static RetrofitUtil getInstance(String baseUrl){
        if (retrofitUtil == null){
            synchronized (RetrofitUtil.class){
                if (retrofitUtil == null){
                    retrofitUtil = new RetrofitUtil(baseUrl);
                }
            }
        }
        return retrofitUtil;
    }

    public <T> T createService(Class<T> service){
        return retrofit.create(service);
    }

    /**
     * 公共参数的拦截器
     */
    private static class CommonParamsInterceptor implements Interceptor{

        //intercept方法就是拦截的意思....拦截的是一个请求,,,一旦拦截之后可以对请求的参数进行处理
        //Chain chain 链条的意思

        @Override
        public Response intercept(Chain chain) throws IOException {

            //调用request()方法得到拦截的请求
            Request request = chain.request();

            //获取请求的方式
            String method = request.method();//GET POST
            //拦截的请求的路径
            String oldUrl = request.url().toString();

            Log.e("----oldUrl",oldUrl);

            //要添加的公共参数...map
            Map<String,String> map = new HashMap<>();
            map.put("source","android");

            if ("GET".equals(method)){
                StringBuilder stringBuilder = new StringBuilder();//创建一个stringBuilder...字符串缓冲区

                stringBuilder.append(oldUrl);

                if (oldUrl.contains("?")){
                    //?在最后面....2类型
                    if (oldUrl.indexOf("?") == oldUrl.length()-1){

                    }else {
                        //3类型...拼接上&
                        stringBuilder.append("&");
                    }
                }else {
                    //不包含? 属于1类型,,,先拼接上?号
                    stringBuilder.append("?");
                }

                //添加公共参数....source=android&appVersion=100&
                for (Map.Entry<String,String> entry: map.entrySet()) {
                    //拼接
                    stringBuilder.append(entry.getKey())
                            .append("=")
                            .append(entry.getValue())
                            .append("&");
                }

                //删掉最后一个&符号
                if (stringBuilder.indexOf("&") != -1){
                    stringBuilder.deleteCharAt(stringBuilder.lastIndexOf("&"));
                }
                //得到含有公共参数的新路径.....使用新路径去请求
                String newUrl = stringBuilder.toString();

                Log.e("----newUrl",newUrl);

                //新的路径构建一个新的请求
                request = request.newBuilder().url(newUrl).build();

            }else if ("POST".equals(method)){

                //参数在请求的实体内容上....拿到以前的参数,把以前的参数和公共参数全都添加到请求实体上
                RequestBody requestBody = request.body();
                if (requestBody instanceof FormBody){//前边是不是后边的子类/实例对象
                    FormBody oldBody = (FormBody) requestBody;//keywords...page

                    FormBody.Builder builder = new FormBody.Builder();

                    //先添加之前的参数
                    for (int i = 0;i<oldBody.size();i++){
                        //键值对的形式添加
                        builder.add(oldBody.name(i),oldBody.value(i));
                    }
                    //添加公共参数
                    for (Map.Entry<String,String> entry: map.entrySet()) {

                        builder.add(entry.getKey(),entry.getValue());
                    }
                    //构建一个新的请求
                    request = request.newBuilder().url(oldUrl).post(builder.build()).build();
                }
            }
            //执行请求 获取到响应
            Response response = chain.proceed(request);
            return response;
        }
    }
}

Application

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
    }

    public static ApiService getApiService() {
        return RetrofitUtil.getInstance(IntegratedUrl.SHBASE_URL).createService(ApiService.class);
    }
}

网址的特殊写法

public class IntegratedUrl {

    public static final String SHBASE_URL = "http://120.27.23.105/";

    public static final String HOBASE_Url = "https://www.zhaoapi.cn/";

    public static final String HOME_URL = "ad/getAd";

    public static final String QUERY_URL = "product/getCarts";

    public static final String ADD_URL = "product/addCart";

    public static final String DELETE_URL = "product/deleteCart";
}