kotlin协程网络请求简单封装okhttp3+retrofit2，可自定义请求头

 添加依赖

implementation "com.squareup.okhttp3:okhttp:4.2.2"
implementation "com.squareup.retrofit2:retrofit:2.9.0"
implementation "com.squareup.retrofit2:converter-gson:2.9.0"
implementation "com.squareup.okhttp3:logging-interceptor:4.9.0"

ApiFactory

import android.util.Log
import android.util.SparseArray
import com.google.gson.GsonBuilder
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit


object ApiFactory {
    private val TAG: String = "HttpLogInfo"
    private val urls: SparseArray<String> = SparseArray()
    private val retrofits: SparseArray<Retrofit> = SparseArray()
    private var customHeaders: Map<String, String> ? = null
    private const val CONNECT_TIMEOUT = 60L
    private const val READ_TIMEOUT = 60L
    private const val WRITE_TIMEOUT = 10L

    /**
     * @param baseUrl 地址
     * @param clazz api
     * @param newHeaders 自定义请求头
     */
    fun <T> createService(
        baseUrl: String,
        clazz: Class<T>,
        newHeaders: Map<String, String>? = null
    ): T {
        val indexOfValue = urls.indexOfValue(baseUrl)
        val retrofit =
            if (newHeaders != customHeaders) {//请求头不相同
                if (indexOfValue >= 0) {
                    //清除之前保存的url请求
                    urls.remove(indexOfValue)
                    retrofits.remove(indexOfValue)
                }
                customHeaders = newHeaders
                //重新获取retrofit
                getRetrofit(baseUrl, newClient(newHeaders))
            } else if (indexOfValue >= 0) {
                //内存中存在直接取出来使用
                retrofits.get(indexOfValue)
            } else {
                //内存中没有则重新获取
                getRetrofit(baseUrl, newClient())
            }
        return retrofit.create(clazz)
    }

    private fun getRetrofit(baseUrl: String, newClient: OkHttpClient): Retrofit =
        Retrofit.Builder().run {
            baseUrl(baseUrl)
            client(newClient)
            addConverterFactory(
                GsonConverterFactory.create(
                    GsonBuilder().serializeNulls().create()
                )
            )
            val build = build()
            val index = urls.size()
            urls.append(index, baseUrl)
            retrofits.append(index, build)
            build
        }

    private fun newClient(headers: Map<String, String>? = null) =
        OkHttpClient.Builder().apply {
            retryOnConnectionFailure(true)
            connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
            readTimeout(READ_TIMEOUT, TimeUnit.SECONDS)
            writeTimeout(WRITE_TIMEOUT, TimeUnit.SECONDS)
            addInterceptor(HttpLoggingInterceptor(HttpLog()).setLevel(HttpLoggingInterceptor.Level.BODY))
            headers?.let {
                //添加自定义请求头
                addInterceptor(Interceptor { chain ->
                    val original: Request = chain.request()
                    val requestBuilder: Request.Builder = original.newBuilder()
                    for ((key, value) in it) {
                        requestBuilder.addHeader(key, value)
                    }
                    val request: Request = requestBuilder.build()
                    chain.proceed(request)
                })
            }
        }.build()

    class HttpLog : HttpLoggingInterceptor.Logger {
        override fun log(message: String) {
            Log.d(TAG, message)
        }
    }
}

使用

自定义请求头，我这里是传的是登录返回的token，根据自己需要传值，也可以不传

object NetworkService {

    private const val BASE_URL = "http://192.168.0.144:8089/test/"

//    val api by lazy { ApiFactory.createService(BASE_URL, Api::class.java) }

    val api by Service()

    class Service {
        operator fun getValue(thisRef: Any, property: KProperty<*>): Api {
            var hashMap :Map<String, String> ?= null
            if (!StringUtils.isTrimEmpty(UserManager.token)) {
                hashMap = HashMap()
                hashMap["Authorization"] = "Bearer ${UserManager.token!!}"
            }
            return ApiFactory.createService(BASE_URL, Api::class.java, hashMap)
        }
    }

}

 根据后端的返回值，定义接收数据实体类的公共字段

open class ResultData<T> {
    var success:Boolean = false
    var errorCode:Int = 0
    var errorMsg:String = ""
    var data:T ?= null
}

class PageResult<T>:ResultData<T>(){
    /**
     * 当前页数
     */
    val currentPage: Int? = null

    /**
     * 当前页数条数
     */
    val currentPageSize: Int? = null

    /**
     * 总页数
     */
    val totalPageSize: Int? = null

    /**
     * 总条数
     */
    val totalSize: Long? = null
}

API接口

interface Api {

    @POST("sys/loginIn")
    suspend fun  login(@Body jsonObject: JsonObject) : ResultData<LoginResult>

    @GET("tPlan/getPlanList")
    suspend fun getPlanList(
        @Query("pageNum") pageNum: Int,
        @Query("pageSize") pageSize: Int,
        @Query("order") order: String? = null
    ): PageResult<List<WaitDealBean>>

}

调用接口

class LoginActivityVM : BaseViewModel() {

    private val _loginState = MutableLiveData<Boolean>().apply {
        value = false
    }
    val loginState: LiveData<Boolean> = _loginState
    
    fun login() = launch({
        val jsonObject= JsonObject()
        jsonObject.addProperty("tel","150")
        jsonObject.addProperty("passWord","123")
        val result = NetworkService.api.login(jsonObject)
        if(result.success){
            _loginState.value = true
            val data = result.data
            UserManager.loginSuccess(data)
        }
    }, onError = {

    })
}