记录的一些Retrofit的小用法

本文仅记录一些在使用Retrofit+OkHttp+RxJava模式时所用到的一些方案，方便查找，说明什么的还是算了吧

自定义转换器

提供的转换器虽方便，可要完全按Json建model还是算了吧

• 最直接的转换器，回调一个JsonObject

    public class CommonConverterFactory extends Converter.Factory {
        private RequestJsonInterface dealInterface;

        @Nullable
        @Override
        public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
            return new JsonResponseBodyConverter<>();
        }

        @Nullable
        @Override
        public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
            return super.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit);
        }

        public CommonConverterFactory() {

        }

        public CommonConverterFactory(RequestJsonInterface dealInterface1) {
            dealInterface = dealInterface1;
        }

        public class JsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
            @Override
            public T convert(ResponseBody value) throws IOException {
                String response = value.string();
                try {
                    JSONObject jsonObject = new JSONObject(response);
                    if (dealInterface != null) {
                        return (T) dealInterface.deal(jsonObject);
                    }else {
                        return (T) new Object();
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }

                return null;
            }
        }

    }

这里建立了一个简单的转换器，其中的JsonResponseBodyConverter会将ResponseBody转换为一个JsonObject，然后可以按照自己的意思处理，自然，也可以对其进行扩展。

通过拦截器进行请求时的自动加密

加密是一个常见需求，以确保传递的正确性，多数时是通过要传递的参数通过一定的算法生成一个加密值，可以通过拦截器获取所有的参数并进行加密

//创建的一个请求工具类的初始化方法
public RequestHelper(int timeOut, final boolean isSignature, final boolean isUserID, Converter.Factory factory) {
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder()
                .connectTimeout(timeOut, TimeUnit.SECONDS)
                .writeTimeout(timeOut, TimeUnit.SECONDS)
                .readTimeout(timeOut, TimeUnit.SECONDS);
        if (!(!isKey & !isSignature)) {
            clientBuilder.addInterceptor(new Interceptor() {
                @Override public Response intercept(Chain chain) throws IOException {
                    Request request = chain.request();
                    Request.Builder requestBuilder = request.newBuilder();
                    if (request.body() instanceof FormBody) {
                        FormBody.Builder builder = new FormBody.Builder();
                        FormBody body = (FormBody)request.body();
                        Map<String, String> param = new HashMap<String, String>();
                        for (int index = 0; index < body.size(); index++) {
                            param.put(body.encodedName(index), body.encodedValue(index));
                            builder.addEncoded(body.encodedName(index), body.encodedValue(index));
                        }
                        
                        if (isKey) {
                        //此处是希望为每一个请求添加一个参数key
                            if (BaseApplication.getKey() != null) {
                                builder.add("key", BaseApplication.getKey());
                                param.put("key", BaseApplication.getKey());
                            }
                        }
                        if (isSignature) {
                        //此处为添加加签参数signature
                            builder.add("signature", encryptParam(param));
                        }
                        requestBuilder.method(request.method(), builder.build());
                    }
                    Request newRequest = requestBuilder.build();
                    return chain.proceed(newRequest);
                }
            });
        }
        clientBuilder.addInterceptor(loggingInterceptor);
        OkHttpClient client = clientBuilder.build();
        Retrofit retrofit = new Retrofit.Builder().baseUrl(BASE_URL).client(client).addConverterFactory(factory)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();
        requestApi = retrofit.create(RequestApi.class);
    }

/**加签函数*/
private String encryptParam(Map<String, String> param) {
    String encrypt = "";
    ***加签过程***
    return encrypt;
}