Android Retrofit的封装（日志、Header、返回、缓存的统一处理）

其他 2021-03-06 02:12:54 阅读次数: 0

封装点

  • 网络Log设置（OKHTTP拦截器）
  • url统一追加参数（OKHTTP拦截器）
  • header统一追加参数（OKHTTP拦截器）
  • body统一追加参数（OKHTTP拦截器）
  • 错误处理，统一错误处理（flag/error）
  • 返回值统一剥离外层包装
  • 缓存设置
  • 超时错误重连机制
  • 不同的BaseUrl使用不同的Retrofit实例，同一个BaseUrl下使用同一个Retrofit实例
  • 所有Retrofit实例公用一个OkhttpClient实例

引入

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.7.2'

header、日志、url

        //header中追加参数
        client.addInterceptor(AppendHeaderParamInterceptor())

        //url追加参数
        client.addInterceptor(AppendUrlParamInterceptor())

        //在Debug模式下设置日志拦截器
        if (BuildConfig.DEBUG) {
    
    
            val logger = HttpLoggingInterceptor().apply {
    
     level = HttpLoggingInterceptor.Level.BODY }
            client.addInterceptor(logger)
        }

/**
 * url追加参数
 */
class AppendUrlParamInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        //1.获取到请求
        val request = chain.request()
        //2.得到之前的url
        val builder = request.url.newBuilder()
        //3.追加信息，得到新的url
        val newUrl = builder.addQueryParameter("deviceId", "123")
                .addQueryParameter("token", "456")
                .build()
        //4.新的url创建新的request
        val newRequest = request.newBuilder()
                .url(newUrl)
                .build()
        //5.返回
        return chain.proceed(newRequest)
    }

}

/**
 * header追加参数
 */
class AppendHeaderParamInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        //1.得到request
        val request = chain.request()
        //2.得到之前的header
        val builder = request.headers.newBuilder()
        //3.追加新的header信息
        val newHeader = builder.add("deviceId", "123")
                .add("token", "456")
                .build()
        //4.创建一个新的请求
        val newRequest = request.newBuilder()
                .headers(newHeader)
                .build()
        //5.返回
        return chain.proceed(newRequest)
    }

}

缓存的统一设置

 /**
   * 只能缓存get请求.
   * 这里我设置了1天的缓存时间
   */
    @Headers("Cache-Control: public, max-age=" + 24*60*60)
    @GET("api/random/data/{type}/{size}")
    suspend fun getRandomUsers(@Path("type") type: String?, @Path("size") size: String?): ApiResponse<User>
  • 以下是通过拦截器统一设置
/**
 * 有网络的时候
 */
class OnlineInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        val request = chain.request()
        val response = chain.proceed(request)
        val onlineCacheTime = 0 //在线的时候的缓存过期时间，如果想要不缓存，直接时间设置为0
        return response.newBuilder()
                .header("Cache-Control", "public, max-age=$onlineCacheTime")
                .removeHeader("Pragma")
                .build()
    }
}

/**
 * 没有网的时候
 */
class OfflineInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        val request = chain.request()
        if (!NetworkUtils.isConnected()) {
    
    
            //从缓存取数据
            val newRequest = request.newBuilder()
                    .cacheControl(CacheControl.FORCE_CACHE)
                    .build()
            val maxTime = 60 * 60 * 24
            val response = chain.proceed(newRequest)
            return response.newBuilder()
                    .removeHeader("Pragma")
                    .header("Cache-Control", "public, only-if-cached, max-stale=$maxTime")
                    .build()
        }
        return chain.proceed(request)
    }
}


        //缓存设置
        val cacheFile = File(PathUtils.getCachePathExternalFirst(), "cache_retrofit")
        val cache = Cache(cacheFile, 1024 * 1024 * 10)
        client.cache(cache)
                .addInterceptor(OfflineInterceptor())
                .addNetworkInterceptor(OnlineInterceptor())

返回结果的统一处理

  • 异常的统一处理
  • 返回结果去除外层的包装，只保留客户端关心的数据
data class ApiResponse<T>(
        val error: Boolean,
        val results: List<T>
)

data class ApiResult<T>(val success: Boolean, val data: T) {
    
    
    companion object {
    
    
        inline fun <T> create(request: () -> ApiResponse<T>): List<T> {
    
    
            return try {
    
    
                val response = request.invoke()
                response.results
            } catch (e: Exception) {
    
    
                if (e is UnknownHostException) {
    
    
                    ToastUtils.showShort("连接服务器失败")
                } else if (e is InterruptedIOException) {
    
    
                    ToastUtils.showShort("连接服务器超时")
                } else if (e is JSONException || e is JsonParseException || e is ParseException) {
    
    
                    ToastUtils.showShort("数据解析出错")
                } else {
    
    
                    ToastUtils.showShort("未知的网络错误")
                }
                Log.e("ApiResult", "create: " + e.message)
                emptyList()
            }
        }
    }
}
  • 调用的地方，Model层
package com.zhangyu.myjetpack.model

import com.zhangyu.myjetpack.api.UserService
import com.zhangyu.myjetpack.bean.User
import com.zhangyu.myjetpack.utils.ApiResult
import com.zhangyu.myjetpack.utils.RetrofitUtil


interface UserRepository {
    
    
    suspend fun getRandomUsers(): List<User>
}

private class UserRepositoryImpl(private val service: UserService) : UserRepository {
    
    

    override suspend fun getRandomUsers(): List<User> {
    
    
        return ApiResult.create {
    
    
            service.getRandomUsers("福利", "10")
        }
    }
}

object UserRepositoryProvider {
    
    
    fun getInstance(): UserRepository {
    
    
        return UserRepositoryImpl(RetrofitUtil.provide(UserService::class.java))
    }
}

完整的代码

package com.zhangyu.myjetpack.utils

import android.util.ArrayMap
import android.util.Log
import com.blankj.utilcode.util.NetworkUtils
import com.blankj.utilcode.util.PathUtils
import com.blankj.utilcode.util.ToastUtils
import com.google.gson.JsonParseException
import com.zhangyu.myjetpack.BuildConfig
import okhttp3.*
import okhttp3.logging.HttpLoggingInterceptor
import org.json.JSONException
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.io.File
import java.io.InterruptedIOException
import java.net.UnknownHostException
import java.text.ParseException

object RetrofitUtil {
    
    

    private const val BASE_URL = "https://gank.io/"

    //创建OkHttp实例
    private var okHttpClient: OkHttpClient

    init {
    
    
        val client = OkHttpClient.Builder()

        //header中追加参数
        client.addInterceptor(AppendHeaderParamInterceptor())

        //url追加参数
        client.addInterceptor(AppendUrlParamInterceptor())

        //缓存设置
        val cacheFile = File(PathUtils.getCachePathExternalFirst(), "cache_retrofit")
        val cache = Cache(cacheFile, 1024 * 1024 * 10)
        client.cache(cache)
                .addInterceptor(OfflineInterceptor())
                .addNetworkInterceptor(OnlineInterceptor())

        //在Debug模式下设置日志拦截器
        if (BuildConfig.DEBUG) {
    
    
            val logger = HttpLoggingInterceptor().apply {
    
     level = HttpLoggingInterceptor.Level.BODY }
            client.addInterceptor(logger)
        }
        okHttpClient = client.build()
    }

    private fun getRetrofit(): Retrofit {
    
    
        //生成Retrofit实例
        return Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build()
    }

    private val mApis = ArrayMap<String, Any>()

    @Suppress("UNCHECKED_CAST")
    fun <T> provide(apiInterfaceClass: Class<T>): T {
    
    
        val api = mApis[apiInterfaceClass.name] as T ?: getRetrofit().create(apiInterfaceClass)
        mApis[apiInterfaceClass.name] = api
        return api
    }

}

/**
 * 有网络的时候
 */
class OnlineInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        val request = chain.request()
        val response = chain.proceed(request)
        val onlineCacheTime = 0 //在线的时候的缓存过期时间，如果想要不缓存，直接时间设置为0
        return response.newBuilder()
                .header("Cache-Control", "public, max-age=$onlineCacheTime")
                .removeHeader("Pragma")
                .build()
    }
}

/**
 * 没有网的时候
 */
class OfflineInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        val request = chain.request()
        if (!NetworkUtils.isConnected()) {
    
    
            //从缓存取数据
            val newRequest = request.newBuilder()
                    .cacheControl(CacheControl.FORCE_CACHE)
                    .build()
            val maxTime = 60 * 60 * 24
            val response = chain.proceed(newRequest)
            return response.newBuilder()
                    .removeHeader("Pragma")
                    .header("Cache-Control", "public, only-if-cached, max-stale=$maxTime")
                    .build()
        }
        return chain.proceed(request)
    }
}

/**
 * url追加参数
 */
class AppendUrlParamInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        //1.获取到请求
        val request = chain.request()
        //2.得到之前的url
        val builder = request.url.newBuilder()
        //3.追加信息，得到新的url
        val newUrl = builder.addQueryParameter("deviceId", "123")
                .addQueryParameter("token", "456")
                .build()
        //4.新的url创建新的request
        val newRequest = request.newBuilder()
                .url(newUrl)
                .build()
        //5.返回
        return chain.proceed(newRequest)
    }

}

/**
 * header追加参数
 */
class AppendHeaderParamInterceptor : Interceptor {
    
    
    override fun intercept(chain: Interceptor.Chain): Response {
    
    
        //1.得到request
        val request = chain.request()
        //2.得到之前的header
        val builder = request.headers.newBuilder()
        //3.追加新的header信息
        val newHeader = builder.add("deviceId", "123")
                .add("token", "456")
                .build()
        //4.创建一个新的请求
        val newRequest = request.newBuilder()
                .headers(newHeader)
                .build()
        //5.返回
        return chain.proceed(newRequest)
    }

}

data class ApiResponse<T>(
        val error: Boolean,
        val results: List<T>
)

object ApiResult {
    
    
    inline fun <T> create(request: () -> ApiResponse<T>): List<T> {
    
    
        return try {
    
    
            val response = request.invoke()
            response.results
        } catch (e: Exception) {
    
    
            if (e is ConnectException) {
    
    
                ToastUtils.showShort("连接服务器失败")
            } else if (e is UnknownHostException) {
    
    
                ToastUtils.showShort("未知服务器异常")
            } else if (e is InterruptedIOException) {
    
    
                ToastUtils.showShort("连接服务器超时")
            } else if (e is JSONException || e is JsonParseException || e is ParseException) {
    
    
                ToastUtils.showShort("数据解析出错")
            } else {
    
    
                ToastUtils.showShort("未知的网络错误")
            }
            Log.e("ApiResult", "create: " + e.message)
            emptyList()
        }
    }
}

okhttp.OkHttpClient: --> GET https://gank.io/api/random/data/%E7%A6%8F%E5%88%A9/10?deviceId=123&token=456
okhttp.OkHttpClient: deviceId: 123
okhttp.OkHttpClient: token: 456
okhttp.OkHttpClient: --> END GET
okhttp.OkHttpClient: <-- 200 OK https://gank.io/api/random/data/%E7%A6%8F%E5%88%A9/10?deviceId=123&token=456 (450ms)
okhttp.OkHttpClient: Server: nginx
okhttp.OkHttpClient: Date: Sat, 23 Jan 2021 09:31:13 GMT
okhttp.OkHttpClient: Content-Type: application/json
okhttp.OkHttpClient: Content-Length: 2777
okhttp.OkHttpClient: Connection: keep-alive
okhttp.OkHttpClient: Expires: Sat, 23 Jan 2021 21:31:13 GMT
okhttp.OkHttpClient: Cache-Control: max-age=43200
okhttp.OkHttpClient: X-Cache: MISS
okhttp.OkHttpClient: Cache-Control: no-cache

猜你喜欢

转载自blog.csdn.net/yu540135101/article/details/113034404
今日推荐
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
周排行
自媒体文章如何提高原创度以及如何检测原创度
开启qq邮箱的smtp服务
Qt程序单次启动（QSingleApplication类）
国外的外包网站
更新IDEA主题——放飞代码风格
cocos2dx 实现搓牌效果（翻牌效果），包括铺平动画
dict和json之间的互相转换
angular的一些思考
. Fibonacci数列是这样定义的： F[0] = 0 F[1] = 1 for each i ≥ 2: F[i] = F[i-1] + F[i-2] 因此，Fibonacci数列就形如：0, 1
洛谷P1064 金明的预算方案
每日归档
更多
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022