http okhttp 去除token 通用方法，未验证

import android.text.TextUtils;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.txx.app.freshman.FreshmanApp;
import com.txx.app.freshman.commom.utils.MyLog;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okio.Buffer;

public class CommonParamsInterceptor1 implements Interceptor {
    private static final String TAG = CommonParamsInterceptor1.class.getSimpleName ();
    private static final String METHOD_GET = "GET";
    private static final String METHOD_POST = "POST";
    private static final String TXX_SIGN = "txxSign";
    private static final String TXX_TOKEN = "token";
    private static final Charset UTF8 = Charset.forName ("UTF-8");

    @Override
    public Response intercept(Chain chain) throws IOException {
        /*获取请求的参数*/
        Request request = chain.request ();
        String method = request.method ();//获取方法


      try {
            HttpUrl.Builder urlBuilder = request.url ().newBuilder ();
            Request.Builder requestBuilder = request.newBuilder ();
            //统一去掉token
            HttpUrl httpUrl = urlBuilder.build ();

            if (METHOD_GET.equals (method)) { // GET方法
                Set<String> paramKeys = httpUrl.queryParameterNames ();
                if (paramKeys != null && paramKeys.size () != 0) {
                    if (paramKeys.contains ("token")) {
                        urlBuilder.removeAllQueryParameters ("token");
                        requestBuilder.url ( urlBuilder.build ());
                    }
                }
            } else if (METHOD_POST.equals (method)) { // POST方法
                //post 方法 加入 query 查询 token 处理
                Set<String> paramKeys = httpUrl.queryParameterNames ();
                if (paramKeys != null && paramKeys.size () != 0) {
                    if (paramKeys.contains ("token")) {
                        urlBuilder.removeAllQueryParameters ("token");
                        requestBuilder.url ( urlBuilder.build ());
                    }
                }
                RequestBody requestBody = request.body ();//获取请求体
                //post 请求处理
                if (requestBody != null && requestBody instanceof FormBody) {
                    FormBody formBody = (FormBody) requestBody;
                    if (formBody != null) {
                        Map<String, String> map = new HashMap<> ();//处理 txxSign
                        for (int i = 0; i < formBody.size (); i++) {
                            if (TXX_TOKEN.equals (formBody.encodedName (i))) {
                                continue;
                            }
                            map.put (formBody.encodedName (i), formBody.encodedValue (i));
                            MyLog.wtf (formBody.encodedName (i), formBody.encodedValue (i));
                        }

                        if (!map.isEmpty ()) {
                            FormBody.Builder builder = new FormBody.Builder ();
                            for (Map.Entry<String, String> m : map.entrySet ()) {
                                builder.add (m.getKey (), m.getValue ());
                            }
                            FormBody formBody1 = builder.build ();
                            requestBuilder = requestBuilder.post (formBody1);

                        }
                    }
                } else {
                    Buffer buffer = new Buffer ();
                    requestBody.writeTo (buffer);
                    String oldJsonParams = buffer.readUtf8 ();
                    HashMap<String, Object> rootMap = new Gson ().fromJson (oldJsonParams, HashMap.class); // 原始参数
                    Map<String, String> map = new HashMap<> ();//处理 txxSign
                    /* 遍历集合*/
                    if (rootMap != null && rootMap.entrySet () != null && rootMap.entrySet ().size () != 0) {
                        for (Map.Entry<String, Object> entry : rootMap.entrySet ()) {
                            String mapKey = entry.getKey ();
                            if (TXX_TOKEN.equals (mapKey)) {
                                continue;
                            }
                            String mapValue = String.valueOf (entry.getValue ());
                            map.put (mapKey, mapValue);
                            MyLog.wtf (mapKey, mapValue);
                        }
                    }
                    String param = new Gson ().toJson (map, HashMap.class); // 原始参数
                    RequestBody body = RequestBody.create (MediaType.parse ("application/json; charset=utf-8"), param);
                    requestBuilder = requestBuilder.post (body);
                }
            }
            return chain.proceed (requestBuilder.build ());
        } catch (IOException e) {
            e.printStackTrace ();
            MyLog.wtf (TAG, "TXX_SIGN 没有， IOException ");
        } catch (JsonSyntaxException e) {
            e.printStackTrace ();
            MyLog.wtf (TAG, "TXX_SIGN 没有， JsonSyntaxException ");
        }
        //如果报异常
        return chain.proceed (request);
    }
}