很是简易的Rxjava2+Retrofit2封装

学习了一段时间Rxjava二、Retrofit2，为了之后项目能直接用，决定本身手动封装一下，虽然网上也有很多Demo，可是为了加深印象，仍是根据本身的理解简单的封装一下。
文章中涉及到的Rxjava二、Retrofit2基础知识就再也不多说，你们自行google便可。

首先写一个mHttpRequest ，做为网络请求接口php

public interface mHttpRequest {
    //参数很简单，可能有人会疑惑，为啥须要传clazz，后面会提到
    <T> void request(String url, Class clazz, mCallBack<T> callBack);

    <T> void request(String url, HttpParameter param, mCallBack<T> callBack);

}
//===================================

public class HttpRequestFactory {
    private static mHttpRequest mHttpRequest;

    public static mHttpRequest getRetrofitHttpRequest() {
        if (mHttpRequest == null) {
            synchronized (HttpRequestFactory.class) {
                if (mHttpRequest == null) {
                    mHttpRequest = new retrofitHttpRequest();
                }
            }
        }
        return mHttpRequest;
    }
}

同时用工厂模式将，网络请求类的对象返回。
这里实例化了一个retrofitHttpRequest类，做为retrofit的请求。这样写的好处也就是若是之后须要更换网络请求框架，直接在HttpRequestFactory里写一个 getXXXXHttpRequest方法便可，不用到每一个网络请求的地方去改。java

接下来就须要实现咱们的retrofitHttpRequest请求类，实现刚刚的mHttpRequest便可。首先获得retrofit、及API的对象。git

public static void init() {
        if (retrofit == null) {
            // 指定缓存路径,缓存大小100Mb
            Cache cache = new Cache(new File(mApplication.getmContext().getCacheDir(), "HttpCache"),
                    1024 * 1024 * 100);
            OkHttpClient client = new OkHttpClient.Builder().cache(cache)
                    .connectTimeout(3, TimeUnit.SECONDS)
                    .retryOnConnectionFailure(true)
                    .build();
            retrofit = new Retrofit.Builder()
                    .client(client)
                    .baseUrl(BASE_URL)
                    .addConverterFactory
                    (GsonConverterFactory.create())
                    .addCallAdapterFactory
                    (RxJava2CallAdapterFactory.create())
                    .build();

            api = retrofit.create(RetrofitApi.class);
        }
    }

//这里是API类
public interface RetrofitApi { 
 
  

    //因为我这里服务器须要json数据，因此用@Body来传参
    @POST
    Observable<HttpResult> getResponse(@Url String url, @Body Map<String, String> parameter);

    //这里踩坑记录：retrofit不支持：<T>type泛型
    @POST
    Observable<HttpResult> getResponse(@Url String url);
}

这里很少说，接下来就是咱们的重点，网络请求的方法github

@Override
    public <T> void request(String url, final HttpParameter param, final mCallBack<T> callBack) {
        api.getResponse(url, param.getParameters())
                .map(new Function<HttpResult, T>() {
                    @SuppressWarnings("unchecked")
                    @Override
    public T apply(HttpResult tHttpResult) throws Exception {
        if (tHttpResult.isStatus()) {
//这里由于api里没有填泛型<T>致使返回的数据不是bean，因此用gson转换一下，这里也就是为何须要用到clazz对象的缘由。
//你们若是有更好的方案能够留言告诉我
return (T) new Gson().fromJson(tHttpResult.getData().toString(), param.getClazz());
        } else {
 throw new Exception(tHttpResult.getMessage());
                        }
                    }
                })
                // 获取异常并进行判断，优雅的返回
                .onErrorResumeNext(new RxjavaFactory.HttpResponseFunc<T>())
                .compose(RxjavaFactory.<T>io_main_trasformer())
                .subscribe(new Observer<T>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e("retrofitHttpRequest", "onSubscribe: ");
                    }

                    @Override
                    public void onNext(T value) {
                        if (value != null)
                            callBack.success(value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        callBack.fail(e.getMessage());
                        Log.e("retrofitHttpRequest", "onError: " + e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e("retrofitHttpRequest", "onComplete: ");
                    }
                });
    }

整个流程也很是简单，至于web

onErrorResumeNext(new RxjavaFactory.HttpResponseFunc<T>())

是为了优雅的返回服务器或其余未知的异常，HttpResponseFunc的代码以下：json

public static class HttpResponseFunc<T> implements Function<Throwable, Observable<T>> { 
 
  
        @Override
        public Observable<T> apply(Throwable throwable) throws Exception {
            return Observable.error(ExceptionUtils.handleException(throwable));
        }
    }

若是产生异常，onErrorResumeNext操做符会处理异常信息，并将咱们自定义的message返回到onError里：api

@Override
                    public void onError(Throwable e) {
                        callBack.fail(e.getMessage());
                        Log.e("retrofitHttpRequest", "onError: " + e.getMessage());
                    }

下面是咱们处理异常信息的工具类：缓存

public class ExceptionUtils { 
 
  
    //对应HTTP的状态码
    private static final int UNAUTHORIZED = 401;
    private static final int FORBIDDEN = 403;
    private static final int NOT_FOUND = 404;
    private static final int REQUEST_TIMEOUT = 408;
    private static final int INTERNAL_SERVER_ERROR = 500;
    private static final int BAD_GATEWAY = 502;
    private static final int SERVICE_UNAVAILABLE = 503;
    private static final int GATEWAY_TIMEOUT = 504;

    public static Exception handleException(Throwable e) {
        String ex;
        if (e instanceof HttpException) {             //HTTP错误
            HttpException httpException = (HttpException) e;
            switch (httpException.code()) {
                case UNAUTHORIZED:
                case FORBIDDEN:
                case NOT_FOUND:
                case REQUEST_TIMEOUT:
                case GATEWAY_TIMEOUT:
                case INTERNAL_SERVER_ERROR:
                case BAD_GATEWAY:
                case SERVICE_UNAVAILABLE:
                default:
                    ex = "网络出错了";  //均视为网络错误
                    break;
            }
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {
            ex = "数据解析错误";            //均视为解析错误
        } else if (e instanceof ConnectException) {
            ex = "网络链接失败";  //均视为网络错误
        } else {
            ex = e.getMessage();         //未知错误或服务器返回
        }
        return new Exception(ex);
    }
}

这样咱们就能返回对应异常信息，对于用户和咱们本身开发都有便利。
对于RXjava优雅的返回异常信息，还不理解的能够戳这里。服务器

这样整个封装就完成了，是否是很简（la）单（ji）。
使用起来也很简单，只须要实现参数类：网络

public class HttpParameter {
    public Map<String,String> parameters;
    public Class clazz;

    public Class getClazz() {
        return clazz;
    }

    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

    public HttpParameter() {
        parameters = new HashMap<>();
    }

    public Map<String, String> getParameters() {
        return parameters;
    }
    public void addParameter(String key,String parameter){
        parameters.put(key,parameter);
    }
}

用法：

HttpParameter parameter = new HttpParameter();
        parameter.addParameter("phone", userName);
        parameter.addParameter
        ("psw",ciPherUtils.Str2MD5LowCase(password));
        parameter.setClazz(UserLoginBean.class);
        HttpRequestFactory.getRetrofitHttpRequest().request
(loginUrl, parameter, new mCallBack<UserLoginBean>() {
            @Override
            public void success(UserLoginBean response) {
                //todo something
            }

            @Override
            public void fail(String message) {
                //message为异常信息哦
            }
        });

因为能力缘由，可能有部分不足之处，但愿你们指出，共同进步。

想要源码的在这里：https://github.com/mrqatom/atomRXDT-MVP 这是一个retrofit2+rxjava2+dagger2+mvp+test+greenDao3的项目，很是适合入门，若是有兴趣也能够star一下哦~ 目前完成了登陆功能，因为是工做之余来写的，因此功能暂时不全，可是我会一直更新，由于实战才能真正提升嘛。