Retrofit+RxJava 完美封装

本来在项目中是使用了Volley 然后封装 封装了一个HttpUtils,

但是由于项目中要引入RxJava,所以就顺便替换一下Volley,使用Retrofit+RxJava。

Volley框架，我这里就 不过多介绍了，大家如果想学习的会可以自己去了解下。

http://blog.csdn.net/ysh06201418/article/details/46443235

首先大家可以参考下其他的Retrofit+RxJava的使用方法。

http://blog.csdn.net/byxyrq/article/details/52672202

如果大家对RxJava还不大了解的话，大家可以看下这篇文章。

http://gank.io/post/560e15be2dca930e00da1083

下面我介绍下我是如何封装Retrofit+RxJava的。

这是我公司的后台返回的json数据格式：

{    data:返回的数据,    errorCode:200,    moreInfo:"错误详情"}

其中'data'中返回的才是我们真正需要的内容，而‘errorCode’不为200，则是后台出错，具体错误信息放在‘moreInfo’中。

而如果直接使用Retrofit+RxJava。如下：

 /**  * 登录  */ @POST @FormUrlEncoded Observable<UserVO> login(@Url String url , @FieldMap Map<String,Object>param);

如果直接使用该接口，那么需要后台直接返回‘UserVO’的json数据。

但是依照前面所说，后台所有的返回数据都是依照

{    data:返回的数据,    errorCode:200,    moreInfo:"错误详情"}

这种格式的数据返回。所以请求这个接口后，其实真正返回的数据应该是如下这样：

{    data:{UserVO对象},    errorCode:200,    moreInfo:"错误详情"}

如上只是一个例子而已，其实所有接口，都是依照这种格式回传，所以在Retrofit+RxJava框架对返回的数据

进行处理之前，需要自己提前处理一下，先判断'errorCode'是否为200,如果为200就是正常请求数据返回，然后

获取到data的数据返回给Retrofit+RxJava框架进行处理。如果不为200，则为错误，根据错误的类型进行相应的处理。

如下：

 /**     * 统一处理原始数据     *     * @param originalResponse     */    private static Response dealResponseData(Response originalResponse) {        String jsonString = null;        try {            BufferedSource bufferedSource = originalResponse.body().source();            jsonString = bufferedSource.readString(Charset.forName("utf-8"));        } catch (Exception e) {            e.printStackTrace();        }        if (!jsonString.trim().startsWith("{") && !jsonString.trim().startsWith("[")) {            return onSuccess(originalResponse, jsonString);        }        ResponseMessageBean msgBean = ResponseMessageBean.analyseReponse(jsonString);        if (msgBean == null) return onSuccess(originalResponse, msgBean.data.toString());        if (msgBean != null && (msgBean.errorCode == 200)) {            showError = true;            if (msgBean.data != null) {                return onSuccess(originalResponse, msgBean.data.toString());            } else {                return originalResponse.newBuilder().body(null).build();            }        } else {            onFailed(msgBean);            throw new RuntimeException(msgBean.moreInfo.toString());        }    }

请求之后返回一个Response对象，预先处理完成之后返回另一新的Response对象，这样就可以实现刚才的目的了。

ResponseMessageBean其实就是最外面的对象。

onSuccess方法中，其实主要对处理后的数据重新组装成一个新的Response对象

private static Response onSuccess(Response originalResponse, String content) {        return originalResponse.newBuilder().                body(ResponseBody.create(null, content)).                build();    }

方法虽然简单，但是这里要注意一点，不能新建一个新的Response返回，因为你Response里面其实是有多数据的，你就使用原来的Response，

然后把body里面的内容替换下就好了。

其实这里还有一个onFailed方法，主要是后台请求报错了，没有返回200，就根据你自己后台定义的值来判断具体错误，然后具体处理，这里

我就不再具体描述了。

前面描述的是data返回值是一个对象，其实是一个数组也是一样的，只要你在泛型里面写的是List那么就会返回一个List对象，如下：

 @POST    @FormUrlEncoded    Observable<List<UserVO>> userList(@Url String url , @FieldMap Map<String,Object>param);

这样处理的数据其实是这种格式的

{    data:[{},{}],    errorCode:200,    moreInfo:"错误详情"}

对了，我这里一直没有讲为什么Retrofit+RxJava会对返回的对象进行自动转换，因为我前面已经放了几篇文章，希望大家能先阅读了

一些基础的知识后，再来看这篇文章的具体封装，可能对你的帮助会更大一点。

Retrofit在初始化：

 Retrofit retrofit = new Retrofit.Builder().baseUrl(UrlConstant.BASEURL).                addConverterFactory(GsonConverterFactory.create()).                addCallAdapterFactory(RxJavaCallAdapterFactory.create()).                client(mOkHttpClient).                build();

addConverterFactory其实是为了对返回内容的提供一个转换器。

这里官方实现了很多种转换器，如下

Gson: com.squareup.retrofit:converter-gson

Jackson: com.squareup.retrofit:converter-jackson

Moshi: com.squareup.retrofit:converter-moshi

Protobuf: com.squareup.retrofit:converter-protobuf

Wire: com.squareup.retrofit:converter-wire

Simple XML: com.squareup.retrofit:converter-simplexml

一共有这么几种，大家可以根据自己的返回格式和喜好，选择对应的转换器，我这里选择了Gson转换器。

记得选择转换器，要引入对应的依赖，这里我就不再过多赘述了。

我这里为什么要讲这个转换器呢？因为在项目的的过程中，我发现了有这样的一个需求，就是返回值中的data不是对象，也不是数组，

如下：

{    data:"你好",    errorCode:200,    moreInfo:"错误详情"}

或者是其他‘boolean’，‘int’等基础类型。就会出错。所以我这里重新对gson转换器做了封装，如下

public class TWGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {    private final Gson gson;    private final TypeAdapter<T> adapter;    private final TypeToken<?> typeToken;    TWGsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter, TypeToken<?> typeToken) {        this.gson = gson;        this.adapter = adapter;        this.typeToken = typeToken;    }    @Override    public T convert(ResponseBody value) throws IOException {        Object obj = checkBasicType(value);        if (obj != null) return (T) obj;        JsonReader jsonReader = gson.newJsonReader(value.charStream());        try {            return adapter.read(jsonReader);        } finally {            value.close();        }    }    /**     * 如果是基本类型就转化后，返回     */    private Object checkBasicType(ResponseBody value) throws IOException {        String typeName = typeToken.getRawType().getSimpleName();        if ("String".equals(typeName)) {            return value.string();        } else if ("Boolean".equals(typeName)) {            return Boolean.parseBoolean(value.string());        } else if ("Integer".equals(typeName)) {            return Integer.parseInt(value.string());        }        return null;    }}

在方法中判断是否为基础类型，如果为基础类型，或者String 就通过处理后，直接返回，如果不是，则还是通过原来的转换器转换。

这样子就可以适用所有情况了。

在我的项目中，有一个场景，就是需要在请求时，自定义请求头，虽然Retrofit有@Head，但是由于每次请求都需要设置，还是直接封装

在里面比较好，代码如下：

private static Request.Builder createRequestHeader(Request.Builder builder) {        builder.header("Content-Type",                "application/x-www-form-urlencoded");        builder.header("User-Agent", getUserAgent());        return builder;    }

其实就是创建一个新的Request返回而已。

然后项目中又说要使用https来访问，所以我又加了下面的代码来支持：

if (mOkHttpClient == null) {                    try {                        X509TrustManager xtm = new X509TrustManager() {                            @Override                            public void checkClientTrusted(X509Certificate[] chain, String authType) {                            }                            @Override                            public void checkServerTrusted(X509Certificate[] chain, String authType) {                            }                            @Override                            public X509Certificate[] getAcceptedIssuers() {                                X509Certificate[] x509Certificates = new X509Certificate[0];                                return x509Certificates;                            }                        };                        SSLContext sslContext = null;                        try {                            sslContext = SSLContext.getInstance("SSL");                            sslContext.init(null, new TrustManager[]{xtm}, new SecureRandom());                        } catch (NoSuchAlgorithmException e) {                            e.printStackTrace();                        } catch (KeyManagementException e) {                            e.printStackTrace();                        }                        HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {                            @Override                            public boolean verify(String hostname, SSLSession session) {                                return true;                            }                        };                        // 指定缓存路径,缓存大小100Mb                        Cache cache = new Cache(new File(mContext.getCacheDir(), "HttpCache"), 1024 * 1024 * 100);                        mOkHttpClient = new OkHttpClient.Builder().                                addInterceptor(mRewriteCacheControlInterceptor).                                retryOnConnectionFailure(false).                                connectTimeout(30, TimeUnit.SECONDS).                                sslSocketFactory(sslContext.getSocketFactory()).                                hostnameVerifier(DO_NOT_VERIFY).                                cache(cache).                                build();                    } catch (Exception e) {                        e.printStackTrace();                    }                }            }

并且还指定了缓存还有超时时间，重试次数，等等。

以上情况其实已经适用我当前项目的所以场景了。

下面是附上所有代码：

public class RetrofitHelper {    private static ServerApi api;    private static OkHttpClient mOkHttpClient;    private static Context mContext;    private static boolean showError = true;    /**     * 启动后初始化     */    public static void init(Context context) {        mContext = context;        initOkHttpClient();        Retrofit retrofit = new Retrofit.Builder().baseUrl(UrlConstant.BASEURL).                addConverterFactory(GsonConverterFactory.create()).                addCallAdapterFactory(RxJavaCallAdapterFactory.create()).                client(mOkHttpClient).                build();        api = retrofit.create(ServerApi.class);    }    /**     * 重置baseUrl     */    public static void resetBaseUrl() {        Retrofit retrofit = new Retrofit.Builder().baseUrl(UrlConstant.BASEURL).                addConverterFactory(TWGsonConverterFactory.create()).                addCallAdapterFactory(RxJavaCallAdapterFactory.create()).                client(mOkHttpClient).                build();        api = retrofit.create(ServerApi.class);    }    public static ServerApi getApi() {        return api;    }    /**     * 统一处理原始数据     *     * @param originalResponse     */    private static Response dealResponseData(Response originalResponse) {        String jsonString = null;        try {            BufferedSource bufferedSource = originalResponse.body().source();            jsonString = bufferedSource.readString(Charset.forName("utf-8"));        } catch (Exception e) {            e.printStackTrace();        }        if (!jsonString.trim().startsWith("{") && !jsonString.trim().startsWith("[")) {            return onSuccess(originalResponse, jsonString);        }        ResponseMessageBean msgBean = ResponseMessageBean.analyseReponse(jsonString);        if (msgBean == null) return onSuccess(originalResponse, msgBean.data.toString());        if (msgBean != null && (msgBean.errorCode == 200)) {            showError = true;            if (msgBean.data != null) {                return onSuccess(originalResponse, msgBean.data.toString());            } else {                return originalResponse.newBuilder().body(null).build();            }        } else {            onFailed(msgBean);            throw new RuntimeException(msgBean.moreInfo.toString());        }    }    /**     * 初始化okHttp     */    private static void initOkHttpClient() {        if (mOkHttpClient == null) {            synchronized (RetrofitHelper.class) {                Interceptor mRewriteCacheControlInterceptor = new Interceptor() {                    @Override                    public Response intercept(Chain chain) throws IOException {                        Request request = chain.request();                        if (!NetworkUtils.isNetworkConnected(mContext)) {                            request = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();                        }                        /**                         * 统一设置请求头                         */                        Request newRequest = createRequestHeader(request.newBuilder()).build();                        Response originalResponse = chain.proceed(newRequest);                        //如果是重定向，那么就执行重定向后返回数据。                        if (originalResponse.isRedirect()) {                            Request redirectRequest = request.newBuilder().url(originalResponse.header("location")).build();                            originalResponse = chain.proceed(redirectRequest);                        }                        originalResponse = dealResponseData(originalResponse);                        return originalResponse;                    }                };                if (mOkHttpClient == null) {                    try {                        X509TrustManager xtm = new X509TrustManager() {                            @Override                            public void checkClientTrusted(X509Certificate[] chain, String authType) {                            }                            @Override                            public void checkServerTrusted(X509Certificate[] chain, String authType) {                            }                            @Override                            public X509Certificate[] getAcceptedIssuers() {                                X509Certificate[] x509Certificates = new X509Certificate[0];                                return x509Certificates;                            }                        };                        SSLContext sslContext = null;                        try {                            sslContext = SSLContext.getInstance("SSL");                            sslContext.init(null, new TrustManager[]{xtm}, new SecureRandom());                        } catch (NoSuchAlgorithmException e) {                            e.printStackTrace();                        } catch (KeyManagementException e) {                            e.printStackTrace();                        }                        HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {                            @Override                            public boolean verify(String hostname, SSLSession session) {                                return true;                            }                        };                        // 指定缓存路径,缓存大小100Mb                        Cache cache = new Cache(new File(mContext.getCacheDir(), "HttpCache"), 1024 * 1024 * 100);                        mOkHttpClient = new OkHttpClient.Builder().                                addInterceptor(mRewriteCacheControlInterceptor).                                retryOnConnectionFailure(false).                                connectTimeout(30, TimeUnit.SECONDS).                                sslSocketFactory(sslContext.getSocketFactory()).                                hostnameVerifier(DO_NOT_VERIFY).                                cache(cache).                                build();                    } catch (Exception e) {                        e.printStackTrace();                    }                }            }        }    }    private static Response onSuccess(Response originalResponse, String content) {        return originalResponse.newBuilder().                body(ResponseBody.create(null, content)).                build();    }    /**     * errorCode 不为200     *     * @param msgBean     */    private static void onFailed(ResponseMessageBean msgBean) {        String alert = "";        if (msgBean == null) {            return;        }        if (msgBean.errorCode != 200) {            if (msgBean.errorCode == 401) {                Observable.create(new Observable.OnSubscribe<Object>() {                    @Override                    public void call(Subscriber<? super Object> subscriber) {                        DialogUtils.alertUserUnauthorized(mContext);                    }                }).subscribeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Object>() {                    @Override                    public void onCompleted() {                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Object o) {                    }                });                return;            } else if (msgBean.errorCode == 301) {                alert = "服务器繁忙，请稍后再试";            } else if (msgBean.errorCode == 302) {                alert = "此次访问已失效哦";            } else if (msgBean.errorCode == 403) {                alert = "接口临时关闭，请稍后再试";            } else if (msgBean.errorCode == 500) {                alert = "服务器繁忙，请稍后再试";            } else if (msgBean.errorCode == -1) {                showError = true;                if (msgBean.moreInfo != null) {                    alert = msgBean.moreInfo.toString();                }            } else {                return;            }            final String alertStr = alert;            Observable.create(new Observable.OnSubscribe<Object>() {                @Override                public void call(Subscriber<? super Object> subscriber) {                    //这里有 window bad token 错误                    try {                        if (showError && !TextUtils.isEmpty(alertStr)) {                            ToastUtils.showToast(mContext, alertStr);                            showError = false;                        }                    } catch (Exception e) {                        e.printStackTrace();                    }                }            }).subscribeOn(AndroidSchedulers.mainThread()).subscribe();        }    }    /**     * 统一处理请求头部数据     *     * @return     */    private static Request.Builder createRequestHeader(Request.Builder builder) {        builder.header("Content-Type",                "application/x-www-form-urlencoded");        builder.header("User-Agent", getUserAgent());        return builder;    }    public static String getUserAgent() {        UserAgentBean userAgent = new UserAgentBean();        userAgent.setDeviceToken(AppUtils.getDeviceId(mContext));        userAgent.setClient("Android");        userAgent.setChannel("xunbao");        if (User.getCurrent() != null) {            userAgent.setUserId(User.getCurrent().getId());        }        PackageInfo info = AppUtils.getPackageInfo(mContext);        if (info != null) {            userAgent.setBuild(info.versionCode + "");            userAgent.setVersion(info.versionName);        }        userAgent.setScreenSize(                DisplayUtils.getScreenSize(mContext));        userAgent.setSafeToken(SharePerferenceUtils.getString(mContext,PreferenceConstant.SAFE_TOKEN));        return userAgent.toString();    }}