在 Android 应用开发中，网络请求必不可少，如何去封装才能使自己的请求代码显得更加简洁优雅，更加方便于以后的开发呢？这里利用 Kotlin 的函数式编程和 Retrofit 来从零开始封装一个网络请求框架，下面就一起来瞧瞧吧！
首先，引入网络请求框架的依赖。
implementation 'com.squareup.okhttp3:okhttp:4.9.1'
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.1'
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
定义拦截器
我们可以先自定义一些拦截器，对一些公共提交的字段做封装，比如 token。在服务器注册成功或者登录成功之后获取 token，过期之后便无法正常请求接口，所以需要在请求接口时判断 token 是否过期，由于接口众多，不可能每个接口都进行判断，所以需要全局设置一个拦截器判断 token。
class TokenInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
var response = chain.proceed(request)
if (response.body == null) {
return response
}
val mediaType = response.body!!.contentType() ?: return response
val type = mediaType.toString()
if (!type.contains("application/json")) {
return response
}
val result = response.body!!.string()
var code = ""
try {
val jsonObject = JSONObject(result)
code = jsonObject.getString("code")
} catch (e: Exception) {
e.printStackTrace()
}
response = response.newBuilder().body(result.toResponseBody(null)).code(200).build()
if (isTokenExpired(code)) {
val newToken = getNewToken() ?: return response
val builder = request.url.newBuilder().setEncodedQueryParameter("token", newToken)
val newRequest = request.newBuilder().method(request.method, request.body)
.url(builder.build()).build()
return chain.proceed(newRequest)
}
return response
}
private fun isTokenExpired(code: String) =
TextUtils.equals(code, "401") || TextUtils.equals(code, "402")
private fun getNewToken() = ServiceManager.instance.refreshToken()
}
这里是 token 过期之后直接重新请求接口获取新的 token，这需要根据具体业务需求来，有些可能是过期之后跳转到登录页面，让用户重新登录等等。
我们还可以再定义一个拦截器，全局添加 token。
class TokenHeaderInterceptor : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
var request = chain.request()
val headers = request.headers
var token = headers["token"]
if (TextUtils.isEmpty(token)) {
token = ServiceManager.instance.getToken()
request = request.newBuilder().addHeader("token", token).build()
}
return chain.proceed(request)
}
}
创建 retrofit
class RetrofitUtil {
companion object {
private const val TIME_OUT = 20L
private fun createRetrofit(): Retrofit {
val interceptor = HttpLoggingInterceptor()
interceptor.level = HttpLoggingInterceptor.Level.BODY
val okHttpClient = OkHttpClient().newBuilder().apply {
addInterceptor(interceptor)
addInterceptor(TokenInterceptor())
addInterceptor(TokenHeaderInterceptor())
retryOnConnectionFailure(true)
connectTimeout(TIME_OUT, TimeUnit.SECONDS)
writeTimeout(TIME_OUT, TimeUnit.SECONDS)
readTimeout(TIME_OUT, TimeUnit.SECONDS)
}.build()
return Retrofit.Builder().apply {
addConverterFactory(GsonConverterFactory.create())
baseUrl(ServiceManager.instance.baseHttpUrl)
client(okHttpClient)
}.build()
}
fun <T> getAPI(clazz: Class<T>): T {
return createRetrofit().create(clazz)
}
}
}
网络请求封装
定义通用基础请求返回的数据结构
private const val SERVER_SUCCESS = "200"
data class BaseResp<T>(val code: String, val message: String, val data: T)
fun <T> BaseResp<T>?.isSuccess() = this?.code == SERVER_SUCCESS
请求状态流程封装，可以根据具体业务流程实现方法。
class RequestAction<T> {
var start: (() -> Unit)? = null
private set
var request: (suspend () -> BaseResp<T>)? = null
private set
var success: ((T?) -> Unit)? = null
private set
var error: ((String) -> Unit)? = null
private set
var finish: (() -> Unit)? = null
private set
fun request(block: suspend () -> BaseResp<T>) {
request = block
}
fun start(block: () -> Unit) {
start = block
}
fun success(block: (T?) -> Unit) {
success = block
}
fun error(block: (String) -> Unit) {
error = block
}
fun finish(block: () -> Unit) {
finish = block
}
}
因为网络请求都是在 ViewModel 中进行的，我们可以定义一个 ViewModel 的扩展函数，用来处理网络请求。
fun <T> ViewModel.netRequest(block: RequestAction<T>.() -> Unit) {
val action = RequestAction<T>().apply(block)
viewModelScope.launch {
try {
action.start?.invoke()
val result = action.request?.invoke()
if (result.isSuccess()) {
action.success?.invoke(result!!.data)
} else {
action.error?.invoke(result!!.message)
}
} catch (ex: Exception) {
action.error?.invoke(getErrorTipContent(ex))
} finally {
action.finish?.invoke()
}
}
}
private const val SERVER_ERROR = "HTTP 500 Internal Server Error"
private const val HTTP_ERROR_TIP = "服务器或者网络连接错误"
fun getErrorTipContent(ex: Throwable) = if (ex is ConnectException || ex is UnknownHostException
|| ex is SocketTimeoutException || SERVER_ERROR == ex.message.toString()
) HTTP_ERROR_TIP else ex.message.toString()
使用案例
定义网络请求接口
interface HttpApi {
@GET("/exampleA/exampleP/exampleI/exampleApi/getNetData")
suspend fun getNetData(@QueryMap params: HashMap<String, String>): BaseResp<NetDataBean>
@GET("/exampleA/exampleP/exampleI/exampleApi/getTestData")
suspend fun getTestData(
@Query("param1") param1: String,
@Query("param2") param2: String
): BaseResp<NetDataBean>
@GET("/exampleA/exampleP/exampleI/exampleApi/{id}")
fun getNetTask(
@Path("id") id: String,
@QueryMap params: HashMap<String, String>,
): Call<BaseResp<TaskBean>>
@FormUrlEncoded
@POST("/exampleA/exampleP/exampleI/exampleApi/confirm")
suspend fun confirm(@Field("id") id: String, @Field("token") token: String): BaseResp<String>
@FormUrlEncoded
@POST("/exampleA/exampleP/exampleI/exampleApi/upload")
suspend fun upload(@FieldMap params: Map<String, String>): BaseResp<String>
}
我们可以写一个网络请求帮助类，用于请求的创建。
class RequestHelper {
private val httpApi = RetrofitUtil.getAPI(HttpApi::class.java)
companion object {
val instance: RequestHelper by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
RequestHelper()
}
}
suspend fun getNetData(params: HashMap<String, String>) = httpApi.getNetData(params)
suspend fun getTestData(branchCode: String, token: String) =
httpApi.getTestData(branchCode, token)
suspend fun getNetTask(id: String, params: HashMap<String, String>) =
httpApi.getNetTask(id, params)
suspend fun confirm(id: String, token: String) = httpApi.confirm(id, token)
suspend fun upload(params: HashMap<String, String>) = httpApi.upload(params)
}
定义用户的意图和 UI 状态
sealed class MainIntent {
object FetchData : MainIntent()
}
sealed class MainUIState {
object Loading : MainUIState()
data class NetData(val data: NetDataBean?) : MainUIState()
data class Error(val error: String?) : MainUIState()
}
ViewModel 中做意图的处理和 UI 状态的变更，根据网络请求结果传递不同的状态，使用定义的扩展方法去执行网络请求，封装过后的网络请求就很简洁方便了，下面演示下具体使用。
class MainViewModel : ViewModel() {
val mainIntent = Channel<MainIntent>(Channel.UNLIMITED)
private val _mainUIState = MutableStateFlow<MainUIState>(MainUIState.Loading)
val mainUIState: StateFlow<MainUIState>
get() = _mainUIState
init {
viewModelScope.launch {
mainIntent.consumeAsFlow().collect {
if (it is MainIntent.FetchData) {
getNetDataResult()
}
}
}
}
private fun getNetDataResult() = netRequest {
start { _mainUIState.value = MainUIState.Loading }
request {
val paramMap = hashMapOf<String, String>()
paramMap["param1"] = "param1"
paramMap["param2"] = "param2"
RequestHelper.instance.getNetData(paramMap)
}
success { _mainUIState.value = MainUIState.NetData(it) }
error { _mainUIState.value = MainUIState.Error(it) }
}
}
这样是不是看起来很简洁呢？接下来，Activity 负责发送意图和接收 UI 状态进行相关的处理就行啦！
class MainActivity : AppCompatActivity() {
private val viewModel by viewModels<MainViewModel>()
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
initData()
observeViewModel()
}
private fun initData() {
lifecycleScope.launch {
viewModel.mainIntent.send(MainIntent.FetchData)
}
}
private fun observeViewModel() {
lifecycleScope.launch {
viewModel.mainUIState.collect {
when (it) {
is MainUIState.Loading -> showLoading()
is MainUIState.NetData -> showText(it.data.toString())
is MainUIState.Error -> showText(it.error)
}
}
}
}
private fun showLoading() {
binding.progressBar.visibility = View.VISIBLE
binding.netText.visibility = View.GONE
}
private fun showText(result: String?) {
binding.progressBar.visibility = View.GONE
binding.netText.visibility = View.VISIBLE
binding.netText.text = result
}
}
文件的上传与下载
如果是文件的上传和下载呢？其实文件还不太一样，这涉及到上传进度，文件的处理等方面，所以，为了方便开发使用，我们可以针对文件单独再做一下封装。
定义文件上传对象
data class UpLoadFileBean(val file: File, val fileKey: String)
自定义 RequestBody，从中获取上传进度。
class ProgressRequestBody(
private var requestBody: RequestBody,
var onProgress: ((Int) -> Unit)?,
) : RequestBody() {
private var bufferedSink: BufferedSink? = null
override fun contentType(): MediaType? = requestBody.contentType()
override fun contentLength(): Long {
return requestBody.contentLength()
}
override fun writeTo(sink: BufferedSink) {
if (bufferedSink == null) bufferedSink = createSink(sink).buffer()
bufferedSink?.let {
requestBody.writeTo(it)
it.flush()
}
}
private fun createSink(sink: Sink): Sink = object : ForwardingSink(sink) {
var bytesWritten = 0L
var contentLength = 0L
override fun write(source: Buffer, byteCount: Long) {
super.write(source, byteCount)
if (contentLength == 0L) {
contentLength = contentLength()
}
bytesWritten += byteCount
CoroutineScope(Dispatchers.Main).launch {
onProgress?.invoke((bytesWritten * 100 / contentLength).toInt())
}
}
}
}
创建 MultipartBody.Part
fun <T> createPartList(action: UpLoadFileAction<T>): List<MultipartBody.Part> =
MultipartBody.Builder().apply {
addFormDataPart("token", ServiceManager.instance.getToken())
action.params?.forEach {
if (it.key.isNotBlank() && it.value.isNotBlank()) {
addFormDataPart(it.key, it.value)
}
}
action.fileData?.let {
addFormDataPart(
it.fileKey, it.file.name, ProgressRequestBody(
requestBody = it.file
.asRequestBody("application/octet-stream".toMediaTypeOrNull()),
onProgress = action.progress
)
)
}
}.build().parts
定义文件上传行为
class UpLoadFileAction<T> {
lateinit var request: (suspend () -> BaseResp<T>)
private set
lateinit var parts: List<MultipartBody.Part>
var params: HashMap<String, String>? = null
private set
var fileData: UpLoadFileBean? = null
private set
fun init(params: HashMap<String, String>?, fileData: UpLoadFileBean?) {
this.params = params
this.fileData = fileData
parts = createPartList(this)
}
var start: (() -> Unit)? = null
private set
var success: (() -> Unit)? = null
private set
var error: ((String) -> Unit)? = null
private set
var progress: ((Int) -> Unit)? = null
private set
var finish: (() -> Unit)? = null
private set
fun start(block: () -> Unit) {
start = block
}
fun success(block: () -> Unit) {
success = block
}
fun error(block: (String) -> Unit) {
error = block
}
fun progress(block: (Int) -> Unit) {
progress = block
}
fun finish(block: () -> Unit) {
finish = block
}
fun request(block: suspend () -> BaseResp<T>) {
request = block
}
}
同样，定义 ViewModel 的扩展函数，用来执行文件上传。
fun <T> ViewModel.upLoadFile(
block: UpLoadFileAction<T>.() -> Unit,
params: HashMap<String, String>?,
fileData: UpLoadFileBean?,
) = viewModelScope.launch {
val action = UpLoadFileAction<T>().apply(block)
try {
action.init(params, fileData)
action.start?.invoke()
val result = action.request.invoke()
if (result.isSuccess()) {
action.success?.invoke()
} else {
action.error?.invoke(result.message)
}
} catch (ex: Exception) {
action.error?.invoke(getErrorTipContent(ex))
} finally {
action.finish?.invoke()
}
}
定义文件上传接口
interface HttpApi {
@Multipart
@POST("/exampleA/exampleP/exampleI/exampleApi/uploadFile")
suspend fun uploadFile(@Part partLis: List<MultipartBody.Part>): BaseResp<String>
}
在 RequestHelper 中定义上传文件方法
class RequestHelper {
private val httpApi = RetrofitUtil.getAPI(HttpApi::class.java)
companion object {
val instance: RequestHelper by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
RequestHelper()
}
}
suspend fun uploadFile(partList: List<MultipartBody.Part>) = httpApi.uploadFile(partList)
}
封装过后的文件上传就很简洁方便了，下面演示下具体使用。
private fun uploadMyFile() = upLoadFile(
params = hashMapOf("param1" to "param1", "param2" to "param2"),
fileData = UpLoadFileBean(File(absoluteFilePath), "file"),
) {
start {
}
request { RequestHelper.instance.uploadFile(parts) }
success {
}
error {
}
finish {
}
}
既然上传文件都有了，那怎么少得了下载呢？其实，下载比上传更简单，下面就来写一下，同样利用了 kotlin 的函数式编程，我们添加 ViewModel 的扩展函数，需要注意的是，由于这边是直接使用 OkHttp 的同步请求，所以把这部分代码放在了 IO 线程中。
fun ViewModel.downLoadFile(
downLoadUrl: String,
dirPath: String,
fileName: String,
progress: ((Int) -> Unit)?,
success: (File) -> Unit,
failed: (String) -> Unit,
) = viewModelScope.launch(Dispatchers.IO) {
try {
val fileDir = File(dirPath)
if (!fileDir.exists()) {
fileDir.mkdirs()
}
val downLoadFile = File(fileDir, fileName)
val request = Request.Builder().url(downLoadUrl).get().build()
val response = OkHttpClient.Builder().build().newCall(request).execute()
if (response.isSuccessful) {
response.body?.let {
val totalLength = it.contentLength().toDouble()
val stream = it.byteStream()
stream.copyTo(downLoadFile.outputStream()) { currentLength ->
val process = currentLength / totalLength * 100
progress?.invoke(process.toInt())
}
success.invoke(downLoadFile)
} ?: failed.invoke("response body is null")
} else failed.invoke("download failed：$response")
} catch (ex: Exception) {
failed.invoke("download failed：${getErrorTipContent(ex)}")
}
}
private fun InputStream.copyTo(
out: OutputStream,
bufferSize: Int = DEFAULT_BUFFER_SIZE,
progress: (Long) -> Unit,
): Long {
var bytesCopied: Long = 0
val buffer = ByteArray(bufferSize)
var bytes = read(buffer)
while (bytes >= 0) {
out.write(buffer, 0, bytes)
bytesCopied += bytes
bytes = read(buffer)
progress(bytesCopied)
}
return bytesCopied
}
然后，使用就会变得很简洁了，如下所示：
fun downloadMyFile(downLoadUrl: String, dirPath: String, fileName: String) =
downLoadFile(
downLoadUrl = downLoadUrl,
dirPath = dirPath,
fileName = fileName,
progress = {
},
success = {
},
failed = {
}
)
作者：阿健君
来源：juejin.cn/post/7266768708139434045
，原图本身是长方形的，通过Modifier修饰符修饰后，很容易变成圆角图片。想一下如果用XML方式来写，是不是要写好多代码呢。
