Retrofit2网络请求拦截器

统一日志上报拦截器：

• 区分Get、POST、Form
• 重新发起请求
• 仅供参考（复杂、不建议）

package com.test.checkpoint.net

import android.net.Uri
import com.test.checkpoint.MainApplication
import com.test.checkpoint.constants.toJson
import com.test.checkpoint.utils.ACache
import com.test.checkpoint.utils.LINK_IP
import com.test.checkpoint.utils.LINK_PORT
import okhttp3.*
import okio.Buffer
import java.io.UnsupportedEncodingException
import java.nio.charset.Charset

class ServiceBusInterceptor : Interceptor {

    lateinit var keyUrl: String

    companion object {
        const val REGEX = "[https]+://([0-9]{1,3}.){3}[0-9]{1,3}(:)?[0-9]{0,5}"
        const val TAG = "ServiceBusInterceptor"
        const val APP_KEY = "7E64C7A55DC221DC2D5BFF3BD61D554B"
        const val SERVICE_KEY_GET = "7f0d95150ee33cec8254b9a9c25f94a7"
        const val SERVICE_KEY = "a79b666b57c13820b9c658f863d5321a"
        const val SERVICE_KEY_1 = "8e5ace94b6903317bba90d5b9990141e"
    }

    override fun intercept(chain: Interceptor.Chain): Response {
        val builder = chain.request().newBuilder()
        builder.addHeader("appKey", APP_KEY)
        keyUrl = "http://$LINK_IP:$LINK_PORT/platform/redirect"
        builder.url(keyUrl)
        when (chain.request().method()) {
            "GET" -> {
                builder.addHeader("serviceKey", SERVICE_KEY_GET)
                return chain.proceed(newGetRequest(chain.request(), builder))
            }
            "POST" -> {
                builder.addHeader("serviceKey", SERVICE_KEY)
                return chain.proceed(newJsonRequest(chain.request(), builder))
            }
        }
        return chain.proceed(builder.build())
    }

    //For Get
    private fun newGetRequest(old: Request, builder: Request.Builder): Request {
        val url = old.url()
        return builder.addHeader("ContentType", "application/json; charset=UTF-8").post(
            RequestBody.create(
                MediaType.parse("application/json; charset=UTF-8"),
                ServiceBusRequest(
                    serviceSuffix(urlRegex(url.toString())),
                    mapOf(
                        "jwt-token" to ACache.get(MainApplication.getContext())
                            .getAsString("jwt_token")
                    )
                ).toJson
            )
        ).build()
    }

    //region application/json
    private fun newJsonRequest(old: Request, builder: Request.Builder): Request {
        val url = old.url()
        val body = old.body()
        body?.let {
            val contentType = body.contentType().toString()
            android.util.Log.e(TAG, "contentType: $contentType")
            when {
                contentType.contains("x-www-form-urlencoded") -> {
                    return builder.addHeader("ContentType", "application/json; charset=UTF-8")
                        .post(
                            RequestBody.create(
                                MediaType.parse("application/json; charset=UTF-8"),
                                bodyToJson(body as FormBody, url.toString())
                            )
                        ).build()
                }
                contentType.contains("json") -> {
                    return builder.addHeader("ContentType", "application/json; charset=UTF-8")
                        .post(
                            RequestBody.create(
                                MediaType.parse("application/json; charset=UTF-8"),
                                bodyToString(body)
                            )
                        ).build()
                }
                else -> return builder.build()
            }
        }
        return builder.build()
    }
    //endregion

    //region application/x-www-form-urlencoded
    private fun newFormRequest(old: Request, builder: Request.Builder): Request {
        val url = old.url()
        val body = old.body()
        body?.let {
            builder.addHeader("ContentType", "x-www-form-urlencoded; charset=UTF-8")
            val formBodyBuilder = FormBody.Builder().apply {
                addEncoded("serviceSuffix", serviceSuffix(urlRegex(url.toString())))
                addEncoded("params", paramsToJson(body as FormBody).toJson)
            }
            builder.post(formBodyBuilder.build())
        }
        return builder.build()
    }
    //endregion

    //region params to json map
    private fun paramsToJson(body: FormBody): Map<String, String> {
        val map = mutableMapOf<String, String>()
        val size = body.size()
        for (i in 0 until size) {
            map[body.name(i)] = body.value(i)
        }
        return map
    }
    //endregion

    //region body to json
    private fun bodyToJson(body: FormBody, url: String): String {
        val tokenMap =
            mapOf("jwt-token" to ACache.get(MainApplication.getContext()).getAsString("jwt_token"))
        return ServiceBusRequest(
            serviceSuffix(urlRegex(url)),
            tokenMap,
            paramsToJson(body)
        ).toJson.replace("\\", "")
    }
    //endregion

    //region body to string
    private fun bodyToString(body: RequestBody): String {
        val buffer = Buffer()
        body.writeTo(buffer)
        return buffer.readString(Charset.defaultCharset())
    }
    //endregion

    //region serviceSuffix
    private fun serviceSuffix(url: String): String {
        var newUrl: String = url.substring(keyUrl.length)
        val tag = "/kits-jcz-server"
        if (newUrl.contains(tag)) {
            newUrl = newUrl.replace(tag, "")
        }
        return newUrl
    }
    //endregion

    private fun urlRegex(url: String) = url.replace(REGEX.toRegex(), keyUrl)

    private fun paramsToJson4Get(url: String): Map<String, String> {
        val map = mutableMapOf<String, String>()
        try {
            val uri: Uri = Uri.parse(url)
            for (paramName in uri.queryParameterNames) {
                val paramValue = uri.getQueryParameter(paramName)
                map[paramName] = java.net.URLDecoder.decode(paramValue, "UTF-8")
                com.test.util.LegoLog.d("${paramName}:${paramValue}")
            }
        } catch (e: UnsupportedEncodingException) {
            e.printStackTrace()
        }
        return map
    }
}

data class ServiceBusRequest(
    var serviceSuffix: String = "",
    var serviceHeader: Map<String, String> = mapOf(),
    var params: Map<String, String> = mapOf()
)

工具类：

val Any.toJson: String
    get() = Gson().toJson(this)