打造终极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网络请求,开发实用,简约
github地址：https://github.com/LPTim/mvp
csdn地址：https://download.csdn.net/download/loocanp/10749238
