Android开发网络框架的演进和封装

最新推荐文章于 2026-03-26 09:43:16 发布

原创最新推荐文章于 2026-03-26 09:43:16 发布 · 1k 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

hudawei996

关注

标签

#android #网络

分类嵌入式与硬件开发

一、Android网络框架的演进历程

1. 第一代：HttpURLConnection与AndroidHttpClient

早期Android开发中，网络请求主要依赖于JDK自带的HttpURLConnection和Android提供的AndroidHttpClient。

// HttpURLConnection示例
URL url = new URL("https://api.example.com/data");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.connect();

// 读取响应
InputStream inputStream = connection.getInputStream();
// 处理数据...

这种方式存在明显不足：

代码冗余，每次请求都需要重复编写连接、设置参数、读取响应等步骤
没有默认的连接池管理
不支持异步请求，需要手动处理线程
错误处理机制不完善

2. 第二代：OkHttp的崛起

随着移动网络的发展，Square公司推出的OkHttp逐渐成为主流选择。OkHttp提供了以下优势：

连接池管理，减少连接建立的开销
自动重连机制
支持HTTP/2和SPDY
拦截器链设计，便于扩展
异步请求API（Callback方式）

OkHttp在Android 4.4及以上版本已成为HttpURLConnection的底层实现。

// OkHttp示例
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
    .url("https://api.example.com/data")
    .build();

client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理失败
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理响应
        String responseData = response.body().string();
    }
});

3. 第三代：Retrofit的出现与流行

为了进一步简化网络请求，特别是RESTful API的调用，Square又推出了Retrofit。Retrofit是对OkHttp的封装，它通过注解方式定义API接口，极大地简化了开发流程：

声明式API定义
自动序列化/反序列化JSON数据
支持RxJava、Coroutine等响应式编程模型
解耦网络请求和业务逻辑

// Retrofit示例
interface ApiService {
    @GET("/api/data")
    suspend fun getData(): Response<DataModel>
}

// 创建Retrofit实例
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .client(okHttpClient)
    .build()

val apiService = retrofit.create(ApiService::class.java)

// 调用API（Coroutine方式）
lifecycleScope.launch {
    try {
        val response = apiService.getData()
        // 处理响应
    } catch (e: Exception) {
        // 处理异常
    }
}

二、网络框架的封装策略

1. 为什么需要封装

统一管理：集中处理网络配置、请求拦截、错误处理
降低耦合：业务层不需要关心网络实现细节
易于维护：当底层网络库变更时，只需修改封装层
功能扩展：添加统一的日志、缓存、重试等功能

2. 封装的核心要素

2.1 单例模式管理Client

object NetworkClient {
    private const val BASE_URL = "https://api.example.com/"
    private val okHttpClient: OkHttpClient by lazy {
        OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .writeTimeout(30, TimeUnit.SECONDS)
            .addInterceptor(LoggingInterceptor())
            .addInterceptor(HeaderInterceptor())
            .build()
    }

    val retrofit: Retrofit by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

2.2 统一的API服务管理

object ApiServiceProvider {
    val apiService: ApiService by lazy {
        NetworkClient.retrofit.create(ApiService::class.java)
    }
    
    val userService: UserService by lazy {
        NetworkClient.retrofit.create(UserService::class.java)
    }
    // 其他服务...
}

2.3 统一的网络请求处理

sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val code: Int?, val message: String?) : NetworkResult<Nothing>()
    object Loading : NetworkResult<Nothing>()
}

class NetworkRepository {
    suspend fun <T> safeApiCall(apiCall: suspend () -> T): NetworkResult<T> {
        return withContext(Dispatchers.IO) {
            try {
                val response = apiCall.invoke()
                NetworkResult.Success(response)
            } catch (e: Exception) {
                // 更详细的异常处理可以根据不同的异常类型返回不同的错误信息
                NetworkResult.Error(null, e.message ?: "Unknown error")
            }
        }
    }
}

2.4 拦截器的使用

class HeaderInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        val requestBuilder = originalRequest.newBuilder()
            .addHeader("Content-Type", "application/json")
            .addHeader("Authorization", "Bearer ${getToken()}")
            // 添加其他公共头部
            
        val request = requestBuilder.build()
        return chain.proceed(request)
    }

    private fun getToken(): String {
        // 从SharedPreferences或其他存储中获取token
        return "your_token_here"
    }
}

class LoggingInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        val startTime = System.nanoTime()
        
        Log.d("NetworkLog", "Sending request: ${request.url()} with headers: ${request.headers()}")
        
        val response = chain.proceed(request)
        
        val endTime = System.nanoTime()
        val duration = (endTime - startTime) / 1e6
        
        Log.d("NetworkLog", "Received response for ${response.request().url()} in $duration ms")
        
        return response
    }
}

三、结合项目的建议实现

如果你目前的项目结构是一个基础的Kotlin Android项目。需要实现网络功能，我建议按照以下步骤进行：

1. 添加必要的依赖

在gradle/libs.versions.toml中添加网络相关库的版本：

[versions]
# 已有版本...
okhttp = "4.12.0"
retrofit = "2.9.0"
gson = "2.10.1"
coroutines = "1.7.3"

[libraries]
# 已有库...
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
okhttp-logging-interceptor = { group = "com.squareup.okhttp3", name = "logging-interceptor", version.ref = "okhttp" }
retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
retrofit-gson = { group = "com.squareup.retrofit2", name = "converter-gson", version.ref = "retrofit" }
kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }

然后在app/build.gradle中添加依赖：

dependencies {
    // 已有依赖...
    
    implementation libs.okhttp
    implementation libs.okhttp.logging.interceptor
    implementation libs.retrofit
    implementation libs.retrofit.gson
    implementation libs.kotlinx.coroutines.android
}

2. 创建网络相关的包和类

在com.xxx.xxxx包下创建以下包和类：

network：存放网络相关的所有类
- client：存放Client相关的类
- service：存放API服务接口
- model：存放数据模型类
- repository：存放数据仓库类
- interceptor：存放拦截器类
- result：存放网络结果相关的类