Retrofit,Gson解析,自定义解析内容(如code=1全部解析,code=0不做解析)

打造终极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

下面看下代码结构

Retrofit,Gson解析,自定义解析内容(如code=1全部解析,code=0不做解析)_第1张图片
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>> getApi1(@Query("time") String requestType);

//    @GET("api/Activity/get_activities?")
//    Observable>> getApi1(@Query("time") String requestType);

//    @FormUrlEncoded
//    @POST("api/Activity/get_activities?")
//    Observable>> getApi1(@Field("time") String requestType);

//    @FormUrlEncoded
//    @POST("api/Activity/get_activities?")
//    Observable>> getApi1(@FieldMap HashMap params);

//    @Multipart
//    @POST("api/Activity/get_activities?")
//    Observable>> getApi1(@PartMap Map map);

    @POST("api/Activity/get_activities?")
    Observable>> 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.
 * 

* 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 responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) { TypeAdapter adapter = gson.getAdapter(TypeToken.get(type)); return new MyGsonResponseBodyConverter<>(gson, adapter); } @Override public Converter 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 implements Converter {
    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 adapter;

    MyGsonRequestBodyConverter(Gson gson, TypeAdapter 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 判断返回值  状态划分
 * 

* 此处很重要 * 为何这样写:因为开发中有这样的需求 当服务器返回假如0是正常 1是不正常 0我们gson 或 fastJson解析数据 * 1我们不想解析(可能返回值出现以前是对象 数据为空变成了数组等等,于是在不改后台代码的情况下 我们前端需要处理) * 但是用了插件之后没有很有效的方法控制解析 所以处理方式为 当服务器返回不等于0时候 其他状态都抛出异常 然后提示 * * @author lp * @date 2018/8/24 */ final class MyGsonResponseBodyConverter implements Converter { private final Gson gson; private final TypeAdapter adapter; MyGsonResponseBodyConverter(Gson gson, TypeAdapter 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 extends DisposableObserver {

    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

你可能感兴趣的:(Retrofit,Gson解析,自定义解析内容(如code=1全部解析,code=0不做解析))