打造终极MVP+Retrofit2+okhttp3+Rxjava2网络请求,开发实用,简约，由于篇幅字数原因 本章讲解服务器返回类型不统一而引发的解析失败问题，继上篇文章传送地址，遗留下来的问题，开发中可能会遇到特殊情况，接口返回正常标识（如code=1），我们用GSON自动化解析全部内容。接口返回异常标识（如code=1001），可能会出现返回的类型不统一，原本是对象内容，但是返回了数组，原本是数组，返回的是对象，导致GSON自动化解析失败，在不改后台代码的情况下，前端处理，解决办法请往下看
抓住人生中的一分一秒，胜过虚度中的一月一年!
前言
目前较火的网络请求其中有MVP+Retrofit2+okhttp3+Rxjava2,于是我也加入了使用行列，在网上找了许多案例，实际代码开发中解决了一些所谓的坑，总结了些内容与大家共享一下，有不足的地方希望大家提出我将进行再次完善。
利用了以下技术点
1.Retrofit2 Retrofit2官网
2.okhttp3 okhttp3官网
3.RxJava2 RxJava2官网
4.MVP
下面看下代码结构
mmm.png
1.导包
//网络请求 compile 'com.squareup.okhttp3:okhttp:3.9.1' compile 'com.squareup.retrofit2:retrofit:2.3.0' //ConverterFactory的Gson依赖包 compile 'com.squareup.retrofit2:converter-gson:2.3.0' //CallAdapterFactory的Rx依赖包 compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0' compile 'io.reactivex.rxjava2:rxandroid:2.0.2'
2.retrofit代码实现，
/** * File descripition: 创建Retrofit * * @author lp * @date 2018/6/19 */ public class ApiRetrofit { public final String BASE_SERVER_URL = BaseContent.baseUrl; private String TAG = "ApiRetrofit %s"; private static ApiRetrofit apiRetrofit; private Retrofit retrofit; private ApiServer apiServer; private static Gson gson; private static final int DEFAULT_TIMEOUT = 15; public ApiRetrofit() { OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder(); httpClientBuilder .cookieJar(new CookieManger(App.getContext())) //这块是添加的管理cookie方法 .addInterceptor(interceptor)//日志拦截 // .addInterceptor(new HeadUrlInterceptor()) .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS) .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS) .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS) .retryOnConnectionFailure(true);//错误重联 retrofit = new Retrofit.Builder() .baseUrl(BASE_SERVER_URL) .addConverterFactory(GsonConverterFactory.create())//添加json转换框架 //支持RxJava2 .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .client(httpClientBuilder.build()) .build(); apiServer = retrofit.create(ApiServer.class); } public static ApiRetrofit getInstance() { if (apiRetrofit == null) { synchronized (Object.class) { if (apiRetrofit == null) { apiRetrofit = new ApiRetrofit(); } } } return apiRetrofit; } public ApiServer getApiService() { return apiServer; } /** * 请求访问quest * response拦截器 */ private Interceptor interceptor = new Interceptor() { @Override public Response intercept(Chain chain) throws IOException { Request request = chain.request(); long startTime = System.currentTimeMillis(); Response response = chain.proceed(chain.request()); long endTime = System.currentTimeMillis(); long duration = endTime - startTime; MediaType mediaType = response.body().contentType(); String content = response.body().string(); // analyzeJson("data", "", content); Logger.wtf(TAG, "----------Request Start----------------"); printParams(request.body()); Logger.e(TAG, "| " + request.toString() + "===========" + request.headers().toString()); Logger.json(content); Logger.e(content); Logger.wtf(TAG, "----------Request End:" + duration + "毫秒----------"); return response.newBuilder() .body(ResponseBody.create(mediaType, content)) .build(); } }; /** * 请求参数日志打印 * * @param body */ private void printParams(RequestBody body) { if (body != null) { Buffer buffer = new Buffer(); try { body.writeTo(buffer); Charset charset = Charset.forName("UTF-8"); MediaType contentType = body.contentType(); if (contentType != null) { charset = contentType.charset(UTF_8); } String params = buffer.readString(charset); Logger.e(TAG, "请求参数： | " + params); } catch (IOException e) { e.printStackTrace(); } } } }
3.新建ApiServer类，注释的都是请求案例
public interface ApiServer { //示例 多种类型请求方式 // @POST("api/Activity/get_activities?") // Observable<BaseModel<List<>>> getApi1(@Query("time") String requestType); // @GET("api/Activity/get_activities?") // Observable<BaseModel<List<>>> getApi1(@Query("time") String requestType); // @FormUrlEncoded // @POST("api/Activity/get_activities?") // Observable<BaseModel<List<>>> getApi1(@Field("time") String requestType); // @FormUrlEncoded // @POST("api/Activity/get_activities?") // Observable<BaseModel<List<>>> getApi1(@FieldMap HashMap<String, String> params); // @Multipart // @POST("api/Activity/get_activities?") // Observable<BaseModel<List<>>> getApi1(@PartMap Map<String, RequestBody> map); @POST("api/Activity/get_activities?") Observable<BaseModel<List<MainBean>>> getMain(@Query("time") String requestType); }
解决办法如下
1、在上述创建retrofit时，Retrofit需要一个指定转换框架，如fastJson，GSON等，我们采取GSON转化，为了便于我们的需求，需要重写一下GSON源码--修改成我们自己重写的GsonConverterFactory
原始的GsonConverterFactory
.addConverterFactory(GsonConverterFactory.create())
改成如下我们重写的MyGsonConverterFactory
.addConverterFactory(MyGsonConverterFactory.create())
总共需要重写三个类
第一个类为：MyGsonConverterFactory源码如下（以下内容复制粘贴即可，和源码一样）
import com.google.gson.Gson; import com.google.gson.TypeAdapter; import com.google.gson.reflect.TypeToken; import java.lang.annotation.Annotation; import java.lang.reflect.Type; import okhttp3.RequestBody; import okhttp3.ResponseBody; import retrofit2.Converter; import retrofit2.Retrofit; /** * File descripition: 重写gson 判断返回值 状态划分 * * @author lp * @date 2018/8/24 */ /** * A {@linkplain Converter.Factory converter} which uses Gson for JSON. * <p> * Because Gson is so flexible in the types it supports, this converter assumes that it can handle * all types. If you are mixing JSON serialization with something else (such as protocol buffers), * you must {@linkplain Retrofit.Builder#addConverterFactory(Converter.Factory) add this instance} * last to allow the other converters a chance to see their types. */ public final class MyGsonConverterFactory extends Converter.Factory { /** * Create an instance using a default {@link Gson} instance for conversion. Encoding to JSON and * decoding from JSON (when no charset is specified by a header) will use UTF-8. */ public static MyGsonConverterFactory create() { return create(new Gson()); } /** * Create an instance using {@code gson} for conversion. Encoding to JSON and * decoding from JSON (when no charset is specified by a header) will use UTF-8. */ @SuppressWarnings("ConstantConditions") // Guarding public API nullability. public static MyGsonConverterFactory create(Gson gson) { if (gson == null) throw new NullPointerException("gson == null"); return new MyGsonConverterFactory(gson); } private final Gson gson; private MyGsonConverterFactory(Gson gson) { this.gson = gson; } @Override public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) { TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type)); return new MyGsonResponseBodyConverter<>(gson, adapter); } @Override public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type)); return new MyGsonRequestBodyConverter<>(gson, adapter); } }
第二个类为：MyGsonRequestBodyConverter源码如下（以下内容复制粘贴即可，和源码一样）
import com.google.gson.Gson; import com.google.gson.TypeAdapter; import com.google.gson.stream.JsonWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.Writer; import java.nio.charset.Charset; import okhttp3.MediaType; import okhttp3.RequestBody; import okio.Buffer; import retrofit2.Converter; /** * File descripition: 重写gson 判断返回值 状态划分 * * @author lp * @date 2018/8/24 */ final class MyGsonRequestBodyConverter<T> implements Converter<T, RequestBody> { private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8"); private static final Charset UTF_8 = Charset.forName("UTF-8"); private final Gson gson; private final TypeAdapter<T> adapter; MyGsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) { this.gson = gson; this.adapter = adapter; } @Override public RequestBody convert(T value) throws IOException { Buffer buffer = new Buffer(); Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8); JsonWriter jsonWriter = gson.newJsonWriter(writer); adapter.write(jsonWriter, value); jsonWriter.close(); return RequestBody.create(MEDIA_TYPE, buffer.readByteString()); } }
第三个类为：MyGsonResponseBodyConverter源码如下（此类需要自定义内容）
说明：convert函数中包含服务器请求下全部内容，我们单独拿出下发的code，message字段，用于状态标识，解析方式有多种，用gson解析或者强转都可以
BaseResult re = gson.fromJson(response, BaseResult.class);
或者
BaseResult re = (BaseResult) response;
拿到code时，如果code和约定正常值不同（如code=1），余下内容没必要进行解析，非1情况一律抛出ApiException异常，转交给onError（）处理
import com.google.gson.Gson; import com.google.gson.TypeAdapter; import com.google.gson.stream.JsonReader; import com.lp.mvp_network.base.ApiException; import com.lp.mvp_network.base.BaseContent; import com.lp.mvp_network.base.BaseResult; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStreamReader; import java.nio.charset.Charset; import okhttp3.MediaType; import okhttp3.ResponseBody; import retrofit2.Converter; import static okhttp3.internal.Util.UTF_8; /** * File descripition: 重写gson 判断返回值 状态划分 * <p> * 此处很重要 * 为何这样写：因为开发中有这样的需求 当服务器返回假如0是正常 1是不正常 0我们gson 或 fastJson解析数据 * 1我们不想解析（可能返回值出现以前是对象 数据为空变成了数组等等，于是在不改后台代码的情况下 我们前端需要处理） * 但是用了插件之后没有很有效的方法控制解析 所以处理方式为 当服务器返回不等于0时候 其他状态都抛出异常 然后提示 * * @author lp * @date 2018/8/24 */ final class MyGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> { private final Gson gson; private final TypeAdapter<T> adapter; MyGsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) { this.gson = gson; this.adapter = adapter; } @Override public T convert(ResponseBody value) throws IOException { String response = value.string(); //自定义解析实体类，只解析数据最外层，如code message BaseResult re = gson.fromJson(response, BaseResult.class); //关注的重点，自定义响应码中非1的情况，一律抛出ApiException异常。 //这样，我们就成功的将该异常交给onError()去处理了。 if (re.getCode() != BaseContent.basecode) { value.close(); throw new ApiException(re.getCode(), re.getMessage()); } //如果是1（数据正常返回），我们正常解析 MediaType mediaType = value.contentType(); Charset charset = mediaType != null ? mediaType.charset(UTF_8) : UTF_8; ByteArrayInputStream bis = new ByteArrayInputStream(response.getBytes()); InputStreamReader reader = new InputStreamReader(bis, charset); JsonReader jsonReader = gson.newJsonReader(reader); try { return adapter.read(jsonReader); } finally { value.close(); } } }
再说明一下上边实现逻辑，期间我们拦截解析一步，先定义一个BaseResult，实体类只含code,和message，解析这个实体类内容，拿到code返回值，与后台比对约定好的状态码（比如1是正常），当返回1，我们不做处理，继续向下解析，如果返回其他值，如0或1001等，我们一律抛出自定义异常处理实体类ApiException，将code和message放进去，到异常里进行逻辑判断，下边贴一下BaseResult，ApiException这俩个类的代码
BaseResult源码如下（这块需要改写为你的项目返回字段名）
/** * File descripition: 状态划分 基类 * * @author lp * @date 2018/8/27 */ public class BaseResult { public String message; public int code; public String getMessage() { return message; } public void setMessage(String message) { this.message = message; } public int getCode() { return code; } public void setCode(int code) { this.code = code; } }
ApiException源码如下
/** * File descripition: 异常处理基类 * * @author lp * @date 2018/8/24 */ public class ApiException extends RuntimeException { private int errorCode; public ApiException(int code, String msg) { super(msg); this.errorCode = code; } public int getErrorCode() { return errorCode; } }
开始分析抛出的异常内容
BaseObserver源码如下（为何凭空出现这个类，可查看链接文章）
点击查看
如果我们项目结构不同，可采取这种思路处理，下边分析解决办法
onError代表数据解析失败，如无网，http链接异常等等，首先需要通过异常类型来判断哪种异常并做对应提示
@Override public void onError(Throwable e) { if (view != null) { view.hideLoading(); } if (e instanceof HttpException) { // HTTP错误 onException(BAD_NETWORK, ""); } else if (e instanceof ConnectException || e instanceof UnknownHostException) { // 连接错误 onException(CONNECT_ERROR, ""); } else if (e instanceof InterruptedIOException) { // 连接超时 onException(CONNECT_TIMEOUT, ""); } else if (e instanceof JsonParseException || e instanceof JSONException || e instanceof ParseException) { // 解析错误 onException(PARSE_ERROR, ""); e.printStackTrace(); } else { if (e != null) { onError(e.toString()); } else { onError("未知错误"); } } }
基本异常分析完毕，再进行分析，通过上述内容可知，服务器返回非1（code=1）情况数据内容都会在onError中（ApiException异常类），所以，我们需要将ApiException提出来得知是哪种异常情况
首先判断异常信息是否包含ApiException
e instanceof ApiException
然后继续向下分析，并分发异常处理
if (e instanceof ApiException) { ApiException exception = (ApiException) e; int code = exception.getErrorCode(); switch (code) { //未登录（这块只是提供个演示） case CONNECT_NOT_LOGIN: view.onErrorCode(new BaseModel(exception.getMessage(), code)); onException(CONNECT_NOT_LOGIN, exception.getMessage()); break; //其他不等于0 的所有状态 default: onException(OTHER_MESSAGE, exception.getMessage()); view.onErrorCode(new BaseModel(exception.getMessage(), code)); break; } }
全部代码如下
import com.google.gson.JsonParseException; import com.lp.mvp_network.base.ApiException; import com.lp.mvp_network.base.BaseContent; import com.lp.mvp_network.utils.NetWorkUtils; import org.json.JSONException; import java.io.InterruptedIOException; import java.net.ConnectException; import java.net.UnknownHostException; import java.text.ParseException; import io.reactivex.observers.DisposableObserver; import retrofit2.HttpException; /** * File descripition: 数据处理基类 * * @author lp * @date 2018/6/19 */ public abstract class BaseObserver<T> extends DisposableObserver<T> { public static final int CODE = BaseContent.basecode; protected BaseView view; /** * 网络连接失败 无网 */ public static final int NETWORK_ERROR = 100000; /** * 解析数据失败 */ public static final int PARSE_ERROR = 1008; /** * 网络问题 */ public static final int BAD_NETWORK = 1007; /** * 连接错误 */ public static final int CONNECT_ERROR = 1006; /** * 连接超时 */ public static final int CONNECT_TIMEOUT = 1005; /** * data为null */ public static final int CONNECT_NULL = 5555; /** * 未登录 与服务器约定返回的值 这里未登录只是一个案例 */ public static final int CONNECT_NOT_LOGIN = 1001; /** * 其他code 提示 */ public static final int OTHER_MESSAGE = 20000; public BaseObserver(BaseView view) { this.view = view; } @Override protected void onStart() { if (view != null) { view.showLoading(); } } @Override public void onNext(T o) { try { if (view != null) { view.hideLoading(); } Gson gson = new Gson(); BaseModel model = gson.fromJson(o.toString(), BaseModel.class); if (model.getData() != null) { onSuccess(o); } else { if (view != null) { model.setErrcode(CONNECT_NULL); model.setErrmsg("怎么会是null呢"); view.onErrorCode(model); onException(model.getErrcode(), model.getErrmsg()); } } } catch (Exception e) { e.printStackTrace(); onError(e.toString()); } } @Override public void onError(Throwable e) { if (view != null) { view.hideLoading(); } if (e instanceof HttpException) { // HTTP错误 onException(BAD_NETWORK, ""); } else if (e instanceof ConnectException || e instanceof UnknownHostException) { // 连接错误 onException(CONNECT_ERROR, ""); } else if (e instanceof InterruptedIOException) { // 连接超时 onException(CONNECT_TIMEOUT, ""); } else if (e instanceof JsonParseException || e instanceof JSONException || e instanceof ParseException) { // 解析错误 onException(PARSE_ERROR, ""); e.printStackTrace(); /** * 此处很重要 * 为何这样写：因为开发中有这样的需求 当服务器返回假如0是正常 1是不正常 当返回0时：我们gson 或 fastJson解析数据 * 返回1时：我们不想解析（可能返回值出现以前是对象 但是现在数据为空变成了数组等等，于是在不改后台代码的情况下 我们前端需要处理） * 但是用了插件之后没有很有效的方法控制解析 所以处理方式为 当服务器返回不等于0时候 其他状态都抛出异常 然后提示 * 代码上一级在 MyGsonResponseBodyConverter 中处理 前往查看逻辑 */ } else if (e instanceof ApiException) { ApiException exception = (ApiException) e; int code = exception.getErrorCode(); switch (code) { //未登录（此处只是案例 供理解） case CONNECT_NOT_LOGIN: view.onErrorCode(new BaseModel(exception.getMessage(), code)); onException(CONNECT_NOT_LOGIN, ""); break; //其他不等于0 的所有状态 default: onException(OTHER_MESSAGE, exception.getMessage()); view.onErrorCode(new BaseModel(exception.getMessage(), code)); break; } } else { if (e != null) { onError(e.toString()); } else { onError("未知错误"); } } } /** * 中间拦截一步 判断是否有网络 这步判断相对准确 此步去除也可以 * * @param unknownError * @param message */ private void onException(int unknownError, String message) { BaseModel model = new BaseModel(message, unknownError); if (!NetWorkUtils.isAvailableByPing()) { model.setErrcode(NETWORK_ERROR); model.setErrmsg("网络不可用，请检查网络连接！"); } onExceptions(model.getErrcode(), model.getErrmsg()); if (view != null) { view.onErrorCode(model); } } private void onExceptions(int unknownError, String message) { switch (unknownError) { case CONNECT_ERROR: onError("连接错误"); break; case CONNECT_TIMEOUT: onError("连接超时"); break; case BAD_NETWORK: onError("网络超时"); break; case PARSE_ERROR: onError("数据解析失败"); break; //未登录 case CONNECT_NOT_LOGIN: // onError("未登录"); break; //正常执行 提示信息 case OTHER_MESSAGE: onError(message); break; //网络不可用 case NETWORK_ERROR: onError("网络不可用，请检查网络连接！"); break; //data==null case CONNECT_NULL: onError(message); break; default: break; } } //消失写到这 有一定的延迟 对dialog显示有影响 @Override public void onComplete() { /* if (view != null) { view.hideLoading(); }*/ } public abstract void onSuccess(T o); public abstract void onError(String msg); }
此篇文章是传送连接这篇文章的分支，想加此情况处理，可将相应代码拷贝到对应目录
后记
感谢“逆水寒_53bd”提出的了几个问题，于是处理之后将文章更新了下
1、onNext特别要注意一下，如果加了抛异常处理不等于1实现模式，onNext这块就没必要再次判断了，和上篇文章代码不一样传送连接，因为加了异常处理，所以这样写，注意注意！！！这块内容code只有一种情况，就是code=1（1代表成功状态），其他值都在onError中，所以内容可直接给onSuccess(o);
@Override public void onNext(T o) { if (view != null) { view.hideLoading(); } onSuccess(o); }
2、开发中可能还会有这种情况，message 和code都返回了值，code返回成功状态，但data返回的是null（按道理data应该是返回对象或者数组，这种恶心的问题纯属后台制造），再进行处理一步
拿到对应的data值，判断是否为null，如果为null，进行定制业务处理，或者提示
@Override public void onNext(T o) { try { if (view != null) { view.hideLoading(); } Gson gson = new Gson(); BaseModel model = gson.fromJson(o.toString(), BaseModel.class); if (model.getData() != null) { onSuccess(o); } else { if (view != null) { model.setErrcode(CONNECT_NULL); model.setErrmsg("怎么会是null呢"); view.onErrorCode(model); onException(model.getErrcode(), model.getErrmsg()); } } } catch (Exception e) { e.printStackTrace(); onError(e.toString()); } }
至此 自定义解析体实现完成
本文章最终实现终极MVP+Retrofit2+okhttp3+Rxjava2网络请求,开发实用,简约
