android Retrofit请求体加密 body加密

更改Converter.Factory 加密

1. Retrofit请求体加密，需要自己去写Factory

public class JsonConverterFactory extends Converter.Factory {
    private static final String TAG = "JsonConverterFactory";
    private final Gson gson;

    public static JsonConverterFactory create() {
        return create(new Gson());
    }

    public static JsonConverterFactory create(Gson gson) {
        return new JsonConverterFactory(gson);

    }

    private JsonConverterFactory(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        this.gson = gson;
    }


    @Nullable
    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new JsonRequestBodyConverter<>(gson, adapter); //请求
    }

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

        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        //TypeAdapter<?> adapter = gson.getAdapter(new TypeToken<>(){}.getType());
        return new JsonResponseBodyConverter<>(gson, adapter); //响应
    }

    /**
     * JsonRequestBodyConverter<T>
     * @param <T>
     */
    public static class JsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
        private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
        private final Gson gson;
        private final TypeAdapter<T> adapter;

        /**
         * 构造器
         */
        public JsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
            this.gson = gson;
            this.adapter = adapter;
        }

        @Override
        public RequestBody convert(T value) throws IOException {

            //这里需要，特别注意的是，request是将T转换成json数据。
            //你要在T转换成json之后再做加密。
            //再将数据post给服务器，同时要注意，你的T到底指的那个对象   这个加密请求体 转换为用自己的加密方式
            String byteDecrypt = DESUtils.encrypt(value.toString(), "");
           // Log.e("=====>", "request中传递的json数据：" + value.toString()); //打印：加密前的json字符串
           // Log.e("=====>", "加密后的字节数组：" + byteDecrypt.toString());//打印：字节数组

            //传入字节数组，创建RequestBody 对象
            return RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),byteDecrypt);
        }
    }

    /**
     * JsonResponseBodyConverter<T>
     * @param <T>
     */
    public class JsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
        private final Gson mGson;//gson对象
        private final TypeAdapter<T> adapter;

        /**
         * 构造器
         */
        public JsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
            this.mGson = gson;
            this.adapter = adapter;
        }

        /**
         * 转换
         *
         * @param responseBody
         * @return
         * @throws IOException
         */
        @Override
        public T convert(ResponseBody responseBody) throws IOException {

      
			// 如果想解密 在这里也可以解密  然后把数据传回去  我在返回数据那里解密	
            //这部分代码参考GsonConverterFactory中GsonResponseBodyConverter<T>的源码对json的处理
            Reader reader = StringToReader(responseBody.string().toString().trim());
            JsonReader jsonReader = gson.newJsonReader(reader);
            try {
                return adapter.read(jsonReader);
            } finally {
                reader.close();
                jsonReader.close();
            }
        }

        /**
         * String转Reader
         * @param json
         * @return
         */
        private Reader StringToReader(String json){
            Reader reader  = new StringReader(json);
            return reader;
        }
    }

2. 加密需要传入的参数是body

 // 这里的数据类型ResponseBody 由根据上面的返回数据类型得到的
 @POST(".....")
    Call<ResponseBody> health_1(@Body String s);

3. 用Retrofit 发起请求

        Retrofit retrofit = new Retrofit.Builder().baseUrl("http:....")
                              .addConverterFactory(JsonConverterFactory.create())
                             .build();
 	Map<String, String> map = new HashMap<>();
	map...
	Gson gson = new Gson();
	String s = gson.toJson(map);
	//    ...传入步骤2中的interface类的类名
	Call<ResponseBody> call = retrofit.create(...).health_1(s);
    call.enqueue(....);

另一种加密

1. 正常写GsonConverterFactory.create()

Retrofit retrofit = new Retrofit.Builder().baseUrl("http:...")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

2. 正常写请求

@POST("...")
    Call<ResponseBody>up_record(@Body RequestBody s);

3. 发起请求

 Retrofit retrofit = new Retrofit.Builder().baseUrl("http:...")
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        Map<String, String> map = new HashMap<>();
        map....
        Gson gson = new Gson();
        String s = gson.toJson(map);
        String s1 = DESUtils.encrypt(s,""); // 加密方式
        RequestBody body = RequestBody.create(MediaType.parse("application/json"), s1); // json 文本请求
        Call<ResponseBody> call = retrofit.create(IHP.class).up_record(body);
        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                try {
                    String decryptString = DESUtils.decrypt(response.body().string(), ""); // 解密 获取数据
                  
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {
              
            }
        });

另：传参是json类型 也用@Body的方式传参

@Body参数提交的类型是'application/json'