第7章网络编程与异步处理

「Generated by Manus, instructions issued by binbinwang」

本章将深入探讨Android的网络编程和异步处理机制，并与iOS的对应技术进行对比。作为一名iOS开发者，了解Android平台的网络和异步处理方式将帮助你更好地设计跨平台应用的网络层。

7.1 HTTP网络请求

Android网络请求基础

Android提供了多种方式进行网络请求，从低级API到高级封装库：

网络权限：

首先，需要在AndroidManifest.xml中添加网络权限：

1 2	<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

HttpURLConnection（基础API）：

fun makeHttpRequest(urlString: String): String {
    var connection: HttpURLConnection? = null
    var reader: BufferedReader? = null
    
    try {
        val url = URL(urlString)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "GET"
        connection.connectTimeout = 15000
        connection.readTimeout = 15000
        connection.connect()
        
        val responseCode = connection.responseCode
        if (responseCode != HttpURLConnection.HTTP_OK) {
            throw IOException("HTTP error code: $responseCode")
        }
        
        val inputStream = connection.inputStream
        reader = BufferedReader(InputStreamReader(inputStream))
        val stringBuilder = StringBuilder()
        
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            stringBuilder.append(line)
        }
        
        return stringBuilder.toString()
    } finally {
        connection?.disconnect()
        reader?.close()
    }
}

// 在协程中使用
suspend fun fetchData(url: String): String = withContext(Dispatchers.IO) {
    makeHttpRequest(url)
}

OkHttp（流行的第三方库）：

// 添加依赖
// implementation "com.squareup.okhttp3:okhttp:4.9.3"

// 创建OkHttpClient实例
val client = OkHttpClient.Builder()
    .connectTimeout(15, TimeUnit.SECONDS)
    .readTimeout(15, TimeUnit.SECONDS)
    .build()

// 同步请求
fun makeOkHttpRequest(urlString: String): String {
    val request = Request.Builder()
        .url(urlString)
        .build()
    
    client.newCall(request).execute().use { response ->
        if (!response.isSuccessful) {
            throw IOException("Unexpected code $response")
        }
        return response.body?.string() ?: ""
    }
}

// 异步请求
fun makeAsyncOkHttpRequest(urlString: String, callback: (String?, Exception?) -> Unit) {
    val request = Request.Builder()
        .url(urlString)
        .build()
    
    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            callback(null, e)
        }
        
        override fun onResponse(call: Call, response: Response) {
            try {
                if (!response.isSuccessful) {
                    throw IOException("Unexpected code $response")
                }
                val responseData = response.body?.string()
                callback(responseData, null)
            } catch (e: Exception) {
                callback(null, e)
            }
        }
    })
}

// 在协程中使用
suspend fun fetchWithOkHttp(url: String): String = withContext(Dispatchers.IO) {
    makeOkHttpRequest(url)
}

Retrofit（基于OkHttp的REST客户端）：

// 添加依赖
// implementation "com.squareup.retrofit2:retrofit:2.9.0"
// implementation "com.squareup.retrofit2:converter-gson:2.9.0"

// 定义API接口
interface ApiService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call<List<Repo>>
    
    @GET("users/{user}/repos")
    suspend fun listReposCoroutine(@Path("user") user: String): List<Repo>
    
    @POST("users/new")
    fun createUser(@Body user: User): Call<User>
    
    @FormUrlEncoded
    @POST("user/edit")
    fun updateUser(
        @Field("first_name") firstName: String,
        @Field("last_name") lastName: String
    ): Call<User>
}

// 数据类
data class Repo(
    val id: Long,
    val name: String,
    val full_name: String,
    val owner: Owner,
    val html_url: String,
    val description: String?
)

data class Owner(
    val login: String,
    val id: Long,
    val avatar_url: String
)

data class User(
    val id: Long,
    val name: String,
    val email: String
)

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

// 创建API服务
val apiService = retrofit.create(ApiService::class.java)

// 使用Call接口
fun fetchRepositories(user: String, callback: (List<Repo>?, Throwable?) -> Unit) {
    val call = apiService.listRepos(user)
    
    call.enqueue(object : retrofit2.Callback<List<Repo>> {
        override fun onResponse(call: Call<List<Repo>>, response: Response<List<Repo>>) {
            if (response.isSuccessful) {
                callback(response.body(), null)
            } else {
                callback(null, HttpException(response))
            }
        }
        
        override fun onFailure(call: Call<List<Repo>>, t: Throwable) {
            callback(null, t)
        }
    })
}

// 使用协程
suspend fun fetchRepositoriesCoroutine(user: String): List<Repo> {
    return apiService.listReposCoroutine(user)
}

// 在ViewModel中使用
class RepoViewModel : ViewModel() {
    private val _repos = MutableLiveData<List<Repo>>()
    val repos: LiveData<List<Repo>> = _repos
    
    private val _error = MutableLiveData<String>()
    val error: LiveData<String> = _error
    
    fun loadRepos(user: String) {
        viewModelScope.launch {
            try {
                val result = fetchRepositoriesCoroutine(user)
                _repos.value = result
            } catch (e: Exception) {
                _error.value = e.message
            }
        }
    }
}

与iOS网络请求对比

iOS的网络请求：

// 1. NSURLSession（基础API）
- (void)makeHttpRequest:(NSString *)urlString completion:(void (^)(NSString *data, NSError *error))completion {
    NSURL *url = [NSURL URLWithString:urlString];
    NSURLSession *session = [NSURLSession sharedSession];
    
    NSURLSessionDataTask *task = [session dataTaskWithURL:url completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
        if (error) {
            completion(nil, error);
            return;
        }
        
        NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
        if (httpResponse.statusCode != 200) {
            NSError *statusError = [NSError errorWithDomain:@"HTTPError" 
                                                       code:httpResponse.statusCode 
                                                   userInfo:nil];
            completion(nil, statusError);
            return;
        }
        
        NSString *responseString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
        completion(responseString, nil);
    }];
    
    [task resume];
}

// 2. AFNetworking（流行的第三方库）
// 添加依赖（通过CocoaPods）
// pod 'AFNetworking', '~> 4.0'

- (void)makeAFNetworkingRequest:(NSString *)urlString completion:(void (^)(id responseObject, NSError *error))completion {
    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
    manager.responseSerializer = [AFJSONResponseSerializer serializer];
    
    [manager GET:urlString 
      parameters:nil 
         headers:nil 
        progress:nil 
         success:^(NSURLSessionDataTask *task, id responseObject) {
             completion(responseObject, nil);
         } 
         failure:^(NSURLSessionDataTask *task, NSError *error) {
             completion(nil, error);
         }];
}

// 3. Alamofire（Swift中流行的网络库）
// 添加依赖（通过CocoaPods）
// pod 'Alamofire', '~> 5.5'

// Swift代码
func makeAlamofireRequest(urlString: String, completion: @escaping (Result<Data, Error>) -> Void) {
    AF.request(urlString).response { response in
        if let error = response.error {
            completion(.failure(error))
            return
        }
        
        if let data = response.data {
            completion(.success(data))
        } else {
            completion(.failure(NSError(domain: "NoDataError", code: -1, userInfo: nil)))
        }
    }
}

// 4. 使用Combine框架（iOS 13+）
// Swift代码
func fetchWithCombine(urlString: String) -> AnyPublisher<Data, Error> {
    guard let url = URL(string: urlString) else {
        return Fail(error: URLError(.badURL)).eraseToAnyPublisher()
    }
    
    return URLSession.shared.dataTaskPublisher(for: url)
        .map(\.data)
        .mapError { $0 as Error }
        .eraseToAnyPublisher()
}

// 使用
let cancellable = fetchWithCombine(urlString: "https://api.example.com/data")
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Request completed successfully")
        case .failure(let error):
            print("Request failed: \(error)")
        }
    }, receiveValue: { data in
        print("Received data: \(data)")
    })

主要差异：

Android使用HttpURLConnection、OkHttp和Retrofit，而iOS使用NSURLSession、AFNetworking和Alamofire
Android的Retrofit提供了声明式API接口定义，而iOS通常使用更命令式的方法
Android使用协程和LiveData处理异步，而iOS使用闭包、GCD和Combine
Android的Retrofit自动处理JSON序列化/反序列化，而iOS需要额外的JSONSerialization或Codable
Android需要在Manifest中声明网络权限，而iOS不需要特殊权限

7.2 异步编程模型

Android异步处理机制

Android提供了多种异步处理机制，从传统的AsyncTask到现代的协程：

Handler和Looper：

// 创建Handler
val handler = Handler(Looper.getMainLooper())

// 延迟执行
handler.postDelayed({
    // 在主线程执行的代码
    textView.text = "Updated after delay"
}, 2000) // 2秒后执行

// 在工作线程中执行任务并返回主线程
Thread {
    // 在工作线程执行的代码
    val result = performHeavyTask()
    
    // 切换回主线程
    handler.post {
        // 在主线程更新UI
        textView.text = result
    }
}.start()

// 自定义Handler和Looper
class WorkerThread : Thread() {
    lateinit var handler: Handler
    
    override fun run() {
        Looper.prepare()
        handler = Handler(Looper.myLooper()!!)
        Looper.loop()
    }
    
    fun quit() {
        Looper.myLooper()?.quit()
    }
}

// 使用自定义工作线程
val workerThread = WorkerThread()
workerThread.start()

// 等待Handler初始化
while (!workerThread::handler.isInitialized) {
    Thread.sleep(10)
}

// 在工作线程执行任务
workerThread.handler.post {
    // 在工作线程执行的代码
    val result = performHeavyTask()
    
    // 切换回主线程
    Handler(Looper.getMainLooper()).post {
        // 在主线程更新UI
        textView.text = result
    }
}

// 退出工作线程
workerThread.quit()

AsyncTask（已弃用）：

// 注意：AsyncTask在Android 11中已弃用
@Suppress("DEPRECATION")
private class DownloadTask : AsyncTask<String, Int, String>() {
    
    override fun doInBackground(vararg urls: String): String {
        val url = urls[0]
        var result = ""
        
        try {
            // 执行网络请求
            val connection = URL(url).openConnection() as HttpURLConnection
            connection.connect()
            
            val inputStream = connection.inputStream
            val reader = BufferedReader(InputStreamReader(inputStream))
            val stringBuilder = StringBuilder()
            
            var line: String?
            while (reader.readLine().also { line = it } != null) {
                stringBuilder.append(line)
                // 更新进度
                publishProgress(stringBuilder.length)
            }
            
            result = stringBuilder.toString()
            
            reader.close()
            inputStream.close()
            connection.disconnect()
        } catch (e: Exception) {
            result = "Error: ${e.message}"
        }
        
        return result
    }
    
    override fun onProgressUpdate(vararg values: Int?) {
        super.onProgressUpdate(*values)
        // 更新进度UI
        progressBar.progress = values[0] ?: 0
    }
    
    override fun onPostExecute(result: String) {
        super.onPostExecute(result)
        // 在主线程更新UI
        textView.text = result
    }
}

// 使用AsyncTask
DownloadTask().execute("https://api.example.com/data")

线程池：

// 创建线程池
val executor = Executors.newFixedThreadPool(4)

// 提交任务
executor.submit {
    // 在工作线程执行的代码
    val result = performHeavyTask()
    
    // 切换回主线程
    Handler(Looper.getMainLooper()).post {
        // 在主线程更新UI
        textView.text = result
    }
}

// 关闭线程池
executor.shutdown()

RxJava：

// 添加依赖
// implementation "io.reactivex.rxjava3:rxjava:3.1.3"
// implementation "io.reactivex.rxjava3:rxandroid:3.0.0"

// 创建Observable
val observable = Observable.create<String> { emitter ->
    try {
        // 执行耗时操作
        val result = performHeavyTask()
        emitter.onNext(result)
        emitter.onComplete()
    } catch (e: Exception) {
        emitter.onError(e)
    }
}

// 订阅Observable
val disposable = observable
    .subscribeOn(Schedulers.io())  // 在IO线程执行
    .observeOn(AndroidSchedulers.mainThread())  // 在主线程观察结果
    .subscribe(
        { result ->
            // 成功回调
            textView.text = result
        },
        { error ->
            // 错误回调
            textView.text = "Error: ${error.message}"
        }
    )

// 取消订阅
disposable.dispose()

协程（Coroutines）：

```
// 添加依赖
// implementation “org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0”

// 在Activity或Fragment中使用
class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    
    val button = findViewById<Button>(R.id.button)
    val textView = findViewById<TextView>(R.id.text_view)
    
    button.setOnClickListener {
        // 启动协程
        lifecycleScope.launch {
            try {
                // 显示加载状态
                textView.text = "Loading..."
                
                // 在IO线程执行耗时操作
                val result = withContext(Dispatchers.IO) {
                    performHeavyTask()
                }
                
                // 自动切换回主线程更新UI
                textView.text = result
            } catch (e: Exception) {
                textView.text = "Error: ${e.message}"
            }
        }
    }
}

private suspend fun fetchData(): String = withContext(Dispatchers.IO) {
    // 模拟网络请求
    delay(2000)  // 延迟2秒
    "Data from server"
}

}

// 在ViewModel中使用
class DataViewModel : ViewModel() {

private val _data = MutableLiveData<String>()
val data: LiveData<String> = _data

private val _isLoading = MutableLiveData<Boolean>()
val isLoading: LiveData<Boolean> = _isLoading

private val _error = MutableLiveData<String?>()
val error: LiveData<String?> = _error

fun loadData() {
    viewModelScope.launch {
        try {
            _isLoading.value = true
            _error.value = null
            
            // 并行执行多个请求
            val result1 = async(Dispatchers.IO) { fetchFromApi1() }
            val result2 = async(Dispatchers.IO) { fetchFromApi2() }
            
            // 等待所有请求完成
            val combinedResult = "${result1.await()} + ${result2.await()}"
            
            _data.value = combinedResult
        } catch (e: Exception) {
            _error.value = e.message
        } finally {
            _isLoading.value = false
        }
    }
}

// 取消所有协程
override fun onCleared() {
    super.onCleared()
    viewModelScope.cancel()
}

}

// Flow（响应式流）
fun getDataFlow(): Flow = flow {
// 发射多个值
emit(“Loading…”)

delay(1000)
emit("25%")

delay(1000)
emit("50%")

delay(1000)
emit("75%")

delay(1000)
emit("Data loaded!")

}.flowOn(Dispatchers.IO) // 在IO线程执行

// 收集Flow
lifecycleScope.launch {
getDataFlow().collect { value ->
// 在主线程更新UI
textView.text = value
}
}

// 转换Flow
viewLifecycleOwner.lifecycleScope.launch {
getDataFlow()
.map { it.uppercase() } // 转换为大写
.filter { it.length > 5 } // 过滤短字符串
.catch { e -> emit(“Error: ${e.message}”) } // 处理错误
.collect { value ->
To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with grep -n in order to find the line numbers of what you are looking for.

BinbinWang's blog