kotlin实现OKgo 并实现简单封装

首先分析一下OKgo，okgo作为现在的一个热门联网框架。
那么他为什么成为热门的框架，我们来看一下。

首先是正常的请求

    OkGo.get<String>("url")
                .headers("请求头", "请求头")
                .params("请求体", "请求体")
                .execute(object : StringCallback() {
                    override fun onSuccess(response: Response<String>) {
                        /**
                         * 成功回调
                         */
                    }

                    override fun onStart(request: Request<String?, out Request<*, *>?>?) {
                        super.onStart(request)
                        /**
                         * 开始回调
                         */
                    }

                    override fun onError(response: Response<String>) {
                        super.onError(response)
                        /**
                         * 错误回调
                         */
                    }

                    override fun onFinish() {
                        super.onFinish()
                        /**
                         * 完成回调
                         */
                    }

                    override fun uploadProgress(progress: Progress) {
                        super.uploadProgress(progress)
                        /**
                         * 上传进度回调
                         */
                    }

                    override fun downloadProgress(progress: Progress) {
                        super.downloadProgress(progress)
                        /**
                         * 下载回调
                         */
                    }
                })

这样大家基本上就明白了，这个联网框架，基本上涵盖了所有的联网功能实现，最主要的是和OKHTTP相比okhttp只能调用一次Response而OKgo的Response.body是一个string。所以不会限制调用次数。

在上传和下载时的进度回调，可以直接更新UI。

然后我们来正式使用OKgo。

首先配置OKgo

    implementation 'com.lzy.net:okgo:3.0.4'
    implementation 'com.lzy.net:okrx2:2.0.2'
    implementation 'com.lzy.net:okserver:2.0.5'
    implementation 'com.google.code.gson:gson:2.8.6'
    implementation 'com.google.code.gson:gson-parent:2.8.6'

gson用不用就看个人了，如果你不用gson解析也是可以的。

然后要写一个OKgo初始化文件

class kotlinApp :Application(){

    override fun onCreate() {
        super.onCreate()
        initReadyOkGo()
    }

    private fun initReadyOkGo() {
        val headers = HttpHeaders()
        val params = HttpParams()
        val builder = OkHttpClient.Builder()
        //log相关
        val loggingInterceptor = HttpLoggingInterceptor("OkGo")
        loggingInterceptor.setPrintLevel(HttpLoggingInterceptor.Level.BODY) //log打印级别
        loggingInterceptor.setColorLevel(Level.INFO) //log颜色级别
        builder.addInterceptor(loggingInterceptor) //debug日志
        //超时时间默认60秒
        builder.readTimeout(OkGo.DEFAULT_MILLISECONDS, TimeUnit.MILLISECONDS) //读取超时时间
        builder.writeTimeout(OkGo.DEFAULT_MILLISECONDS, TimeUnit.MILLISECONDS) //写入超时时间
        builder.connectTimeout(OkGo.DEFAULT_MILLISECONDS, TimeUnit.MILLISECONDS) //连接超时时间


        OkGo.getInstance().init(this) //初始化
                .setOkHttpClient(builder.build())
                .setCacheMode(CacheMode.NO_CACHE) //全局统一缓存模式
                .setCacheTime(CacheEntity.CACHE_NEVER_EXPIRE) //全局统一缓存时间，
                .setRetryCount(1) //全局统一超时重连次数
                .addCommonHeaders(headers) //公共头
                .addCommonParams(params) //公共参数
    }

}

然后在AndroidManifest中配置

 <application
        android:name="kotlinApp "
        android:allowBackup="true"
        android:icon="@drawable/app_icon"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme.NoActionBar"
        android:usesCleartextTraffic="true">
       

接下来就可以使用了

创建一个存在网址的文件

class urlAddress {

    private val BASE_URL = "http://testIp:textPoxy"

    val getVerificationCode = "$BASE_URL/textUrl"
}

然后简单封装一下联网降低耦合

创建一个文件存放联网方法和解析方法

    class test {

    var context: Context? = null
    var activity: Activity? = null
    fun test(context: Context?, activity: Activity?) {
        this.context = context
        this.activity = activity
    }

    /**
     * 联网请求方法
     */
    fun getTest(test: String?,stringCallback: StringCallback?) {
        OkGo.get<String>(urlAddress.test)
                .headers("test", test)
                .params("test", test)
                .execute(stringCallback)
    }

    /**
     * 解析方法
     */

    open fun getData(s: String?, res: String?): MutableList<*>? {
        Log.e("测试list", res)
        val list: ArrayList<Any?> = ArrayList<Any?>()
        var jsonObject: JSONObject? = null

            try {
                jsonObject = JSONObject(s)
            } catch (e: JSONException) {
                e.printStackTrace()
            }
            val jsonArray: JSONArray?
            var massage: String? = null
          
            val code = jsonObject!!.optInt("Code")
            val jsonObject1 = jsonObject!!.optJSONObject("Data")
            if (code != 0) {
                jsonArray = null
            } else {
                jsonArray = jsonObject1.optJSONArray("list")
                massage = jsonObject1.optString("Message")
            }
            list.add(code)
            list.add(massage)
            list.add(jsonArray)
        return list
    }
}

最后activity中调用

 private void initNewsData(){
        val test = test(this, this)

        test.test(test, object : StringCallback() {
            override fun onError(response: Response<String>) {
                super.onError(response)
               
            }

            override fun onSuccess(response: Response<String>) {
                val list = test.getData(response.body(), response.code().toString())
               
                  
            }
        })
}

可能也会有人问我为什么不用单例模式，其实很简单。
当判断到异地登录或者token过期时，可以在解析方法中直接判断 response.code()，然后返回到登录界面。实现了token验证的统一管理。简化了view层的代码。

 fun isToken(s: Int) {
        Log.e("测试错误码", s.toString() + "")
        if (s == 406) {
            status = "登录身份已过期,请重新登录"
            backLogin()
        } else if (s == 410) {
            status = "检测到您存在异地登录，请重新登录"
            backLogin()
        } else {
            
        }
    }

基本使用的话到现在已经没有问题了。