网络 - OkHttp

一、概念

二、基本使用

2.1 get请求

fun getCall() {
    //创建客户端
    val client = OkHttpClient.Builder()
        .connectTimeout(5000, TimeUnit.MILLISECONDS)
        .build()
    //创建请求
    val request = Request.Builder()
        .get()
        .url("https://www.baidu.com")
        .build()
    //创建任务
    val call = client.newCall(request)
    //执行任务
    call.enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            Log.d("ErrorMsg", e.toString())
        }
        override fun onResponse(call: Call, response: Response) {
            //结果码==200
            if (response.code == HttpURLConnection.HTTP_OK) {
                response.body
                //（反序列化，json转bean）
                val dataBean = Gson().fromJson(response.body.toString(), DataBean::class.java)
            }
        }
    })
}

2.2 post请求

fun postCall() {
    //创建客户端
    val client = OkHttpClient.Builder()
        .connectTimeout(5000, TimeUnit.MILLISECONDS)
        .build()
    //创建要提交的内容（序列化，内容转bean再转json）
    val dataBean = DataBean("张三")
    val jsonStr = Gson().toJson(dataBean)
    val mediaType = "application/json".toMediaTypeOrNull()
    val requestBody = jsonStr.toRequestBody(mediaType)
    //创建请求
    val request = Request.Builder()
        .post(requestBody)
        .url("https://www.baidu.com")
        .build()
    //创建任务
    val call = client.newCall(request)
    //执行任务
    call.enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            Log.d("ErrorMsg", e.toString())
        }
        override fun onResponse(call: Call, response: Response) {
            Log.d("Result", response.body.toString())
        }
    })
}

三、使用缓存

当某些网络访问获取的内容是短时间不变的（每月榜单）或长时间不变的（歌曲的信息），每次访问都联网获取数据的话，会重复浪费用户和公司的流量费用和带宽占用。

服务端侧缓存	当客户端重复访问一张图片地址时，服务器会判断这个请求有没有缓存，有的话就直接返回掉这个请求，而不是到达真正的服务器地址，依次减轻运算压力。
客户端侧缓存	客户端将服务器返回的数据缓存在本地，再次访问同一地址的时候，客户端会检测本地是否有缓存，如果有且未过期就直接使用缓存内容。

使用 Cache	客户端能够同服务端一起协同开发，以服务器设置的消息头缓存策略为准。
使用 Interceptor	没法协同开发，自己设置 Cache-Control 来控制缓存策略，Interceptor 可以拿到 Request 和 Response。属于一刀切，经常更新和很久更新的数据无法细分处理。
使用 CacheControl	每个 Request 有它自己的缓存时间。

3.1 使用 Cache（自适应服务器配置）

设置好Cache后，同一个地址访问两次打印Log：第一次访问的response.networkResponse( )有内容（来自网络）而response.cacheResponse( ) = null；第二次访问相反，response.cacheResponse( )有内容（来自缓存）而response.networkResponse( ) = null。

private val cache by lazy {
    //缓存存放路径
    val cacheFile = File(APP.context.externalCacheDir, "retrofitCache")
    //缓存大小100M
    val cacheSize = (1024 * 1024 * 100).toLong()
    //创建缓存对象
    Cache(cacheFile, cacheSize)
}

private val okHttpClient by lazy {
    OkHttpClient.Builder()
        .cache(cache)    //设置缓存
        .build()
}

3.2 使用 Interceptor（自行配置Response）

private val intercept = object : Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        val response = chain.proceed(request).apply {
            newBuilder()
                .removeHeader("pragma")
                .header("Cache-Control","max-age=60")
                .build()
        }
        return response
    }
}

private val okHttpClient by lazy {
    OkHttpClient.Builder()
        .chache(cache)
        .addNetworkInterceptor(intercept)   //添加网络拦截器
        .build()
}

3.3 使用 CacheControl（自行配置Request）

类中提供了两个已经定义好的，通过伴生对象调用，一般根据有无网络访问来返回不同的对象。也可以根据需求通过 CacheControl.Builder() 自定义。

CacheControl.FORCE_NETWORK	只获取网络数据。
CacheControl.FORCE_CACHE	只读取本地缓存。

noStore()	不使用缓存，也不存储缓存。
onlyIfCached()	只使用缓存。
noTransform()	禁止转码。
maxAge(10, TimeUnit.MILLISECONDS)	超时时间为10ms。
maxStale(10, TimeUnit.SECONDS)	超时之外的超时时间为10s。
minFresh(10, TimeUnit.SECONDS)	超时时间为当前时间加上10秒钟。

private val intercept = object : Interceptor{
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request().apply {
            val cacheControl = CacheControl.Builder()
                .maxAge(60,TimeUnit.SECONDS)    //缓存缓存有效期60秒
                .build()
            newBuilder()
//              .cacheControl(CacheControl.FORCE_CACHE)    //使用定义好的
                .cacheControl(cacheControl)    //使用自定义的
                .build()
        }
        val response = chain.proceed(request)
        return response
    }
}

private val okHttpClient by lazy {
    OkHttpClient.Builder()
        .chache(cache)
        .addNetworkInterceptor(intercept)   //添加网络拦截器
}