使用HttpClien请求application/json类型接口

接口要求：

application/json

提交参数格式为：

{
  "params": {
    "approveState": 1,
    "id": "货源id"
  },
  "requestNo": 202103181638250020,
  "requestTime": 20210318163825,
  "systemType": "ios/android/web/api",
  "systemVersion": "v1.0.0"
}

引入包：

'com.squareup.okhttp3:logging-interceptor:4.7.2'

使用HttpClient实现

package com.qidian.driver_client_new.utils

import android.app.Dialog
import android.os.Handler
import android.text.TextUtils
import android.util.Log
import com.alibaba.fastjson.JSONException
import com.google.gson.Gson
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import org.json.JSONObject
import java.io.IOException


/**
 * @Description:
 * @QQ :  834672307
 * @Author :  文阿花
 * @Email :
 * @Date :  2021/7/26 0026 15:43
 */
object Network {
    private var loadingDialog: Dialog? = null

    //通过单例类得到的OkHttpClient 对象
    private val mClient: OkHttpClient

    //解析服务器返回数据的Gson
    private val mGson: Gson
    private val mHandler: Handler

    /**
     * 执行普通的post请求，参数集合全部转为json字符串
     *
     * @param map  传入的参数集合
     * @param netCallBack  回调接口
     */
    fun performPost(mUrl: String, params: HashMap<String,Any>, model: Class<*>?, netCallBack: NetCallBack) {

        val JSON = "application/json; charset=utf-8".toMediaTypeOrNull()
        val body = RequestBody.create(JSON, params.mapToJson())
        val request: Request = Request.Builder()
            .url(mUrl)
            .header("Authorization", "Bearer " + DataServer.mUserToken)
            .header("loginName", DataServer.mUserPhone)
            .header("loginType", "APP")
            .post(body)
            .build()
        mClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                doFailure(netCallBack)
            }

            @Throws(IOException::class)
            override fun onResponse(call: Call, response: Response) {
                doResponse(response, model, netCallBack)
            }
        })
    }

    

    /**
     * 处理失败
     *
     * @param netCallBack
     */
    private fun doFailure(netCallBack: NetCallBack) {
        mHandler.post { netCallBack.onNetFailure() }
    }

    /**
     * 处理成功
     *
     * @param response
     * @param netCallBack
     * @throws IOException
     */
    @Throws(IOException::class)
    private fun doResponse(response: Response, model: Class<*>?, netCallBack: NetCallBack) {
        val result = response.body!!.string()
        if (!TextUtils.isEmpty(result)) {
            Log.e("http-result",result)
            try {
                val jsonObject = JSONObject(result)
                val success = jsonObject.getString("code")
                if ("900" == success) {
                    mHandler.post {
                        var `object` = JSONObject(result)
                        val gson = Gson()
                        var data = gson.fromJson(`object`.toString(), model)
                        Log.i("JsonData=", result)
                        netCallBack.onSuccess(data as Object)
                    }
                } else {
                    mHandler.post {
                        netCallBack.onError(jsonObject.getString("message"), result) }//result为了兼容
//                    mHandler.post { netCallBack.onError(result, "") }
                }
            } catch (e: JSONException) {
                e.printStackTrace()
                mHandler.post { //服务器返回错误
                    netCallBack.onError(result, "")
                }
            } catch (e: org.json.JSONException) {
                e.printStackTrace()
                mHandler.post {
                    netCallBack.onError(result, "") }
            }
        }
    }

    /**
     * 回调接口
     */
    interface NetCallBack {
        //网络请求失败，没连网
        fun onNetFailure()

        //网络请求成功
        fun onSuccess(result: Object)

        //网络请求成功，后台服务器有误
        fun onError(result: String?, errorMessage: String?)
    }

    init {
        mClient = OkHttpClientInstance.getInstance()
        mGson = Gson()
        mHandler = Handler()
    }
}

 /**
     * map集合转json
     * @param map
     * @return
     */
    private fun mapToJson(map: Map<String, Any>): String {
        val jsonStr = com.alibaba.fastjson.JSONObject.parseObject(JSON.toJSONString(map))
        return jsonStr.toJSONString()
    }

package com.qidian.zjlw.utils;

import java.util.concurrent.TimeUnit;

import okhttp3.OkHttpClient;

/**
 * @Description:
 * @QQ :  834672307
 * @Author :  文阿花
 * @Email :
 * @Date :  2021/7/26 0026 15:46
 */
public class OkHttpClientInstance {
    public static OkHttpClient instance;

    private OkHttpClientInstance() {}

    public static OkHttpClient getInstance() {
        if (instance == null) {
            synchronized (OkHttpClientInstance.class) {
                if (instance == null) {
                    //配置了网络请求的超时时间
                    instance = new OkHttpClient().newBuilder()
                            .connectTimeout(10, TimeUnit.SECONDS)
                            .readTimeout(10, TimeUnit.SECONDS)
                            .writeTimeout(10, TimeUnit.SECONDS)
                            .build();

                }
            }
        }
        return instance;
    }
}