kotlin 封装OkHttp

先了解一下RequestBody几种类型

 //RequestBody的数据格式都要指定Content-Type，常见的有三种：
    //    1、application/x-www-form-urlencoded 数据是个普通表单  这是默认的方式
    //    2、multipart/form-data 数据里有文件
    //    3、application/json 数据是个json

第一种默认类型在源码FormBody里面可以找到

public final class FormBody extends RequestBody {
  private static final MediaType CONTENT_TYPE =
      MediaType.parse("application/x-www-form-urlencoded");

fun postJsonAsync(file:File) {
        //这是第一种方式
//        var requestBody = FormBody.Builder().add("key", "value").add("key","value").build()

        //第二种方式 json
//        var Json:MediaType = MediaType.parse("application/json; charset=utf-8")!!
//        var requestBody = RequestBody.create(Json,"你的json")

        //第三种方式 文件
        var requestBody = MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("file", file.name, RequestBody.create(MediaType.parse("image/png"), file))
            .build()
    }

源码

import android.os.Handler
import android.os.Looper
import com.google.gson.Gson
import com.google.gson.internal.`$Gson$Types`
import okhttp3.*
import java.io.File
import java.io.IOException
import java.lang.Exception
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type

object OkHttpManager {
    private val mOkHttpClient by lazy {
        OkHttpClient().newBuilder().apply {
            this.connectTimeout(40,TimeUnit.SECONDS)
            this.readTimeout(40,TimeUnit.SECONDS)
            this.writeTimeout(40,TimeUnit.SECONDS)
        }.build()
    }

    private val mHandler by lazy {
        Handler(Looper.getMainLooper())
    }

    private val mGson by lazy {
        Gson()
    }

    //同步get请求
    private fun getSync(url: String): Response {
        val request = Request.Builder().url(url).build()
        val call = mOkHttpClient.newCall(request)
        return call.execute()
    }

    private fun getSyncString(url: String): String {
        return getSync(url).toString()
    }

    //异步get请求
    fun getAsync(url: String, callback: ResultCallback<*>) {
        val request = Request.Builder()
            .url(url)
            .build()
        deliverResult(callback, request)
    }

    //异步post请求
    fun postAsync(url: String, map: Map<String, String>, callback: ResultCallback<*>) {
        val formBody = FormBody.Builder().apply {
            for (key in paramsMap.keys){
                this.add(key,paramsMap[key])
            }
        }.build()
        val request = Request.Builder().url(url).post(formBody).build()
        deliverResult(callback, request)
    }

    private fun deliverResult(callback: ResultCallback<*>, request: Request) {
        mOkHttpClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                sendFailureStringCallback(request, e, callback)
            }

            override fun onResponse(call: Call, response: Response) {
                val string = response?.body()!!.string()
                val mObject = mGson.fromJson<Any>(string, callback.mType)
                sendSuccessResultCallback(mObject, callback as ResultCallback<Any>)
            }

        })
    }

    fun sendFailureStringCallback(request: Request, exception: Exception, callback: ResultCallback<*>) {
        mHandler.post {
            callback.onError(request, exception)
        }
    }

    fun sendSuccessResultCallback(mObject: Any, callback: ResultCallback<Any>) {
        mHandler.post {
            callback.onResponse(mObject)
        }
    }

}

abstract class ResultCallback<T> {
    val mType: Type  by lazy {
        getSuperclassTypeParameter(javaClass)
    }

    companion object {
        fun getSuperclassTypeParameter(subclass: Class<*>): Type {
            val superclass = subclass.genericSuperclass
            if (superclass is Class<*>) {
                throw RuntimeException("Miss type parameter.")
            }
            val parameterizedType = superclass as ParameterizedType
            return `$Gson$Types`.canonicalize(parameterizedType.actualTypeArguments[0])
        }
    }

    abstract fun onError(request: Request, exception: Exception)

    abstract fun onResponse(response: T)
}

使用的时候就这样用就可以了

OkHttpManager.getAsync(url,object : ResultCallback<Any>() {
            override fun onError(request: Request, exception: Exception) {
                tv.text = exception.toString()
            }

            override fun onResponse(response: Any) {
                tv.text = response.toString()
            }

        })