【Compose Multiplatform跨端声明式UI实用技术】第13课:网络层——Ktor在CMP中的集成

69 阅读18分钟

第12课完成了平台抽象机制的学习。本课进入平台能力与互操作模块的核心实践:Ktor Client的多平台引擎选择与配置、kotlinx.serialization与JSON处理、拦截器与认证的跨平台配置、Repository模式在共享代码中的实现、网络状态的UI表达,以及生产级网络层的完整架构设计。本课内容基于Ktor 3.6.0、kotlinx.serialization 1.9.0与CMP 1.12.1。 文末附有15道配套习题与本课知识点总结。

目录

一、为什么选择Ktor:跨平台网络请求的架构决策

1.1 单平台方案的局限

在单平台开发中,网络请求的选型很直接:Android用Retrofit + OkHttp,iOS用URLSession,桌面端用各种HTTP客户端。但CMP项目需要在commonMain中编写共享的网络代码,这意味着必须选择一个能在所有平台上运行的HTTP客户端。

选择标准有三个:纯Kotlin实现(不依赖JVM或Native平台特有API)、协程原生支持(与Compose的异步模型一致)、可插拔的引擎抽象(各平台用最优的底层实现)。Ktor Client同时满足这三个标准,它是JetBrains官方维护的异步HTTP客户端,完全用Kotlin编写,基于协程,通过“引擎”抽象让开发者在共享代码中编写请求逻辑,在各平台使用不同的底层实现。

1.2 引擎抽象:一套代码,多套底层

Ktor的核心设计是客户端与引擎分离。HttpClient是commonMain中使用的API,不关心底层如何发送请求。真正的网络操作由“引擎”完成,每个平台选择最合适的引擎。Ktor 3.6.0引入了 ktor-client-engine-defaults 构件,为目标平台提供精选的默认引擎,大多数KMP项目无需在平台特定源集中单独声明引擎依赖。

平台Ktor 3.6.0默认引擎底层实现
Android / JVMOkHttpOkHttp
iOS / macOSDarwinNSURLSession
Linux / WindowsCIO纯Kotlin协程实现
Web(Wasm)JsFetch API

Ktor 3.6.0的关键改进:ktor-client-engine-defaults 引入后,在 commonMain 中只需一行依赖声明,即可创建 HttpClient() 而无需选择引擎。Ktor会自动为每个目标选择适当的可用引擎。这消除了此前需要在每个平台源集中重复声明引擎依赖的样板代码。

下面是 Ktor 引擎抽象的整体架构图:

mermaid diagram

1.3 使用 engine-defaults 还是 expect/actual?

原则:只有当不同平台确实需要特殊配置时,才使用 expect/actual。如果只是选择一个能工作的引擎,ktor-client-engine-defaults 已经覆盖了绝大多数场景。不要为了“用了KMP”而写 expect/actual。

需要 expect/actual 的场景:Android需要OkHttp连接池调优、iOS需要TLS证书固定、iOS需要 setAllowsCellularAccess 等平台特有网络配置。

二、依赖配置与HttpClient创建

2.1 版本目录配置

在 gradle/libs.versions.toml 中声明依赖:

[versions]
ktor = "3.6.0"
kotlinx-serialization = "1.9.0"

[libraries]
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
ktor-client-auth = { module = "io.ktor:ktor-client-auth", version.ref = "ktor" }
ktor-client-engine-defaults = { module = "io.ktor:ktor-client-engine-defaults", version.ref = "ktor" }
ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }

2.2 源集依赖分配

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation(libs.ktor.client.core)
            implementation(libs.ktor.client.content.negotiation)
            implementation(libs.ktor.serialization.kotlinx.json)
            implementation(libs.ktor.client.logging)
            implementation(libs.ktor.client.auth)
            implementation(libs.ktor.client.engine.defaults)
        }
        commonTest.dependencies {
            implementation(libs.ktor.client.mock)
        }
    }
}

仅当需要平台特定引擎配置时,才在对应源集中添加引擎依赖并显式指定。

三、HttpClient的完整配置

3.1 共享HttpClient的创建

HttpClient的创建和配置集中在commonMain中完成:

fun createHttpClient(engine: HttpClientEngine? = null): HttpClient {
    return if (engine != null) {
        HttpClient(engine) { configureHttpClient() }
    } else {
        HttpClient { configureHttpClient() } // 自动选择引擎
    }
}

private fun HttpClientConfig<*>.configureHttpClient() {
    install(ContentNegotiation) {
        json(Json {
            ignoreUnknownKeys = true
            isLenient = true
            encodeDefaults = true
            explicitNulls = false
        })
    }

    install(Logging) {
        level = LogLevel.INFO
        logger = object : Logger {
            override fun log(message: String) { println("[HTTP] $message") }
        }
    }

    // ⚠️ HttpRequestRetry 必须在 HttpTimeout 之前安装
    install(HttpRequestRetry) {
        retryOnServerErrors(maxRetries = 3)
        exponentialDelay()
    }

    install(HttpTimeout) {
        requestTimeoutMillis = 30_000
        connectTimeoutMillis = 15_000
        socketTimeoutMillis = 30_000
    }

    defaultRequest {
        url("https://api.example.com/")
        header("Accept", "application/json")
    }
}

插件安装顺序至关重要:HttpRequestRetry 必须在 HttpTimeout 之前安装,以便为超时配置重试策略。如果先安装 HttpTimeout,重试策略可能无法正确感知超时事件。

3.2 平台特定引擎配置

当需要对特定平台引擎进行自定义配置时,通过 expect/actual 提供引擎实例:

// commonMain
expect fun createPlatformHttpClient(): HttpClient

// androidMain
actual fun createPlatformHttpClient(): HttpClient = HttpClient(OkHttp) {
    engine {
        config {
            retryOnConnectionFailure(true)
            connectTimeout(15, TimeUnit.SECONDS)
        }
    }
    configureHttpClient()
}

// iosMain
actual fun createPlatformHttpClient(): HttpClient = HttpClient(Darwin) {
    engine {
        configureRequest {
            setAllowsCellularAccess(true)
        }
    }
    configureHttpClient()
}

3.3 HttpClient的生命周期管理

HttpClient 是重量级对象,应作为单例管理。通过Koin注入:

@Module
@ComponentScan("com.example.app")
class NetworkModule {
    @Singleton
    fun provideHttpClient(): HttpClient = createHttpClient()
}

下面是 HttpClient 的插件链配置流程图:

mermaid diagram

四、数据模型与JSON序列化

4.1 定义可序列化的数据模型

@Serializable
data class UserDto(
    val id: Long,
    val name: String,
    @SerialName("avatar_url") val avatarUrl: String? = null,
    val email: String? = null,
)

关键实践:使用 @SerialName 处理API字段名与Kotlin属性名不一致的情况;为可选字段提供默认值;Json { ignoreUnknownKeys = true } 确保服务端添加新字段时客户端不会崩溃。

4.2 处理嵌套结构与密封类

@Serializable
data class ApiResponse<T>(
    val code: Int,
    val message: String,
    val data: T? = null,
)

对于响应体可能返回不同结构的场景,使用密封类配合自定义序列化器:

@Serializable
sealed interface ApiResult<out T> {
    @Serializable
    data class Success<T>(val data: T) : ApiResult<T>

    @Serializable
    data class Error(val code: Int, val message: String) : ApiResult<Nothing>
}

五、认证与拦截器

5.1 Bearer Token认证

Ktor的Auth插件通过 bearer 认证方式在每个请求中自动添加Authorization头。当多个请求同时因401失败时,客户端仅执行一次令牌刷新——第一个收到401响应的请求会触发 refreshTokens 回调。

install(Auth) {
    bearer {
        loadTokens {
            BearerTokens(
                accessToken = tokenStorage.getAccessToken(),
                refreshToken = tokenStorage.getRefreshToken(),
            )
        }
        refreshTokens {
            val newTokens = refreshClient.post("/auth/refresh") {
                setBody(RefreshRequest(tokenStorage.getRefreshToken()))
            }.body<TokenResponse>()

            tokenStorage.saveTokens(newTokens)
            BearerTokens(newTokens.accessToken, newTokens.refreshToken)
        }
        sendWithoutRequest { request ->
            request.url.host == "api.example.com"
        }
    }
}

刷新令牌的注意事项:refreshTokens 块中使用一个独立的 refreshClient(不安装Auth插件),避免刷新请求自身触发认证循环,导致无限递归。

5.2 Ktor 3.6.0的类型安全认证

Ktor 3.6.0引入了类型安全认证能力,通过类型化API保证复杂认证场景的类型安全。同时新增OpenID Connect(OIDC)插件,支持自动发现和配置OpenID Connect提供商。

val jwtAuth = jwt<User>("my-jwt") {
    verifier(jwkProvider, issuer)
    validate { credential ->
        val payload = credential.payload
        User(id = payload.subject, email = payload.getClaim("email").asString())
    }
}

5.3 请求重试策略

install(HttpRequestRetry) {
    retryOnServerErrors(maxRetries = 3)
    retryOnExceptionOrServerErrors(maxRetries = 2)
    exponentialDelay(base = 2.0, maxDelayMs = 10_000)
}

重要区分:401(认证状态恢复)和503/网络错误(瞬时故障恢复)是两种不同的恢复链路,不应混在一起。401触发Auth插件的 refreshTokens,503/网络错误触发 HttpRequestRetry 的重试逻辑。

下面是认证与重试的完整流程图:

mermaid diagram

六、Repository模式:隔离网络与UI

6.1 分层架构

网络层应遵循清晰的职责划分:

ViewModel  ← 屏幕状态、事件处理
    ↓
Repository ← 数据来源决策(Remote/Local/Cache)
    ↓
ApiService ← 定义API端点(语义化方法名)
    ↓
NetworkClient ← 请求执行、Pre-check、异常映射
    ↓
HttpClient  ← Ktor客户端、插件链、引擎

Repository的职责边界:Repository关心的是数据来自Remote还是Local、是否需要Cache、什么时候同步。它不应该关心Authorization Header、HttpTimeout、Ktor Plugin、OkHttp Engine或Darwin Engine。

6.2 safeApiCall:统一的错误处理

sealed interface ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>
    data class Error(val error: AppError) : ApiResult<Nothing>
}

suspend fun <T> safeApiCall(block: suspend () -> T): ApiResult<T> {
    return try {
        ApiResult.Success(block())
    } catch (e: CancellationException) {
        throw e // ⚠️ 必须重新抛出,不要吞掉协程取消
    } catch (e: Exception) {
        ApiResult.Error(e.toAppError())
    }
}

fun Throwable.toAppError(): AppError = when (this) {
    is HttpRequestTimeoutException -> AppError.Timeout
    is ClientRequestException -> AppError.Client(code = response.status.value)
    is ServerResponseException -> AppError.Server(code = response.status.value)
    is IOException -> AppError.Network
    else -> AppError.Unknown(message ?: "未知错误")
}

sealed interface AppError {
    data object Network : AppError
    data object Timeout : AppError
    data class Server(val code: Int) : AppError
    data class Client(val code: Int) : AppError
    data class Unknown(val message: String) : AppError
}

关键点:CancellationException 必须重新抛出,否则协程取消会被误当作网络错误处理,破坏结构化并发。断网和超时是两种不同的错误——断网时 HttpClient 甚至没有执行,超时是请求进入引擎后等待超过时间阈值。

下面是 Repository 模式的完整分层架构图:

mermaid diagram

七、网络状态的UI表达

7.1 从UiState到UI渲染

class UserViewModel(
    private val userRepository: UserRepository,
) : ViewModel() {
    private val _uiState = MutableStateFlow(UserUiState())
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()

    fun loadUser(userId: Long = 1) {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true, error = null) }

            when (val result = userRepository.getUser(userId)) {
                is ApiResult.Success -> _uiState.update {
                    it.copy(user = result.data, isLoading = false)
                }
                is ApiResult.Error -> _uiState.update {
                    it.copy(error = result.error, isLoading = false)
                }
            }
        }
    }
}

data class UserUiState(
    val user: User? = null,
    val isLoading: Boolean = false,
    val error: AppError? = null,
)

7.2 UI层的状态渲染

@Composable
fun UserScreen(viewModel: UserViewModel = koinViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()

    when {
        state.isLoading -> LoadingIndicator()
        state.error != null -> ErrorContent(
            error = state.error,
            onRetry = { viewModel.loadUser() },
        )
        state.user != null -> UserContent(state.user)
    }
}

八、网络层的跨平台注意事项

8.1 断网预检查

Internet连通性和局域网连通性必须区分——Android设备可能没有公网连接,但可以通过Wi-Fi访问局域网设备。

// commonMain
expect fun isNetworkAvailable(): Boolean

// androidMain
actual fun isNetworkAvailable(): Boolean {
    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = cm.activeNetwork ?: return false
    val caps = cm.getNetworkCapabilities(network) ?: return false
    return caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
}

8.2 iOS平台的网络配置

iOS的Darwin引擎基于NSURLSession。iOS上的网络请求默认会在应用进入后台时被系统挂起。如果需要在后台继续下载,需要配置后台会话。

8.3 Web(Wasm)平台的CORS

Wasm平台通过Fetch API发起请求,受浏览器同源策略约束。服务端需要配置CORS头,否则请求会被浏览器拦截。

8.4 测试策略

使用 ktor-client-mock 引擎进行单元测试。注意:MockEngine 必须通过构造函数注入到 HttpClient 中,而非使用顶层属性——否则测试中的MockEngine不会被使用。

// commonTest
class UserApiServiceTest {
    private val mockEngine = MockEngine { request ->
        when (request.url.encodedPath) {
            "/users/1" -> respond(
                content = """{"id":1,"name":"Alice"}""",
                status = HttpStatusCode.OK,
                headers = headersOf(HttpHeaders.ContentType, "application/json"),
            )
            else -> respondError(HttpStatusCode.NotFound)
        }
    }

    private val client = HttpClient(mockEngine) { configureHttpClient() }

    @Test
    fun `getUser returns correct user`() = runTest {
        val api = UserApiServiceImpl(client)
        val user = api.getUser(1L)
        assertEquals("Alice", user.name)
    }
}

九、生产级网络架构设计

9.1 完整请求生命周期

ApiService.getUser(userId)
  → NetworkClient.get()
  → Connectivity Pre-check
  → HttpClient
  → DefaultRequest → Auth → Logging → HttpTimeout → HttpRequestRetry → Engine
  → HTTP Response
  → ContentNegotiation (JSON反序列化)
  → ApiService → Repository → ViewModel → UiState

9.2 共享与下沉的边界

commonMain中共享:ApiService、NetworkClient、NetworkConfig、Provider Interface、ApiResponse、AppError、ExceptionMapper、JSON Config、Auth Logic、Retry Policy、Plugin Config。

下沉到平台层:Engine、Connectivity Monitor、Secure Storage、平台日志实现、证书/TLS、平台差异处理。

9.3 多Client作用域

不同用途的请求可能需要不同的HttpClient配置:

@Module
class NetworkModule {
    @Singleton(named = "api")
    fun provideApiClient(): HttpClient = HttpClient {
        configureHttpClient()
        install(Auth) { bearer { /* ... */ } }
    }

    @Singleton(named = "upload")
    fun provideUploadClient(): HttpClient = HttpClient {
        install(HttpTimeout) { requestTimeoutMillis = 120_000 }
    }

    @Singleton(named = "local")
    fun provideLocalClient(): HttpClient = HttpClient {
        defaultRequest { url("http://192.168.1.100/") }
    }
}

下面是完整的请求生命周期流程图:

mermaid diagram

配套习题(15题)

第一组:引擎抽象与依赖配置(4题)

第1题 Ktor Client引擎抽象的核心价值是( )

A. 减少代码量 B. 在commonMain中编写请求逻辑,各平台使用不同的底层网络实现 C. 提高编译速度 D. 自动处理所有网络错误

答案:B

解析:Ktor的核心设计是客户端与引擎分离。HttpClient是commonMain中使用的API,不关心底层如何发送请求。真正的网络操作由引擎完成,每个平台选择最合适的引擎。

第2题 Ktor 3.6.0中,KMP项目推荐的引擎依赖管理方式是( )

A. 在每个平台源集中手动声明引擎依赖 B. 使用 ktor-client-engine-defaults 构件,自动为目标平台提供默认引擎 C. 只在commonMain中声明引擎依赖 D. 使用反射动态选择引擎

答案:B

解析:Ktor 3.6.0引入了 ktor-client-engine-defaults 构件,为目标平台提供精选的默认引擎,无需在平台特定源集中声明单独的引擎依赖。

第3题 Ktor 3.6.0为Android/JVM平台提供的默认引擎是( )

A. CIO B. OkHttp C. Darwin D. Js

答案:B

解析:Ktor 3.6.0的默认引擎配置:Android/JVM使用OkHttp,Apple平台使用Darwin,Linux/Windows使用CIO,wasmJs使用Js(Fetch API)。

第4题 以下哪种场景适合使用 expect/actual 来提供平台特定的HttpClient配置?( )

A. 所有平台都使用相同的默认配置 B. Android需要OkHttp连接池调优,iOS需要TLS证书固定 C. 只需要选择一个能工作的引擎 D. 不需要任何平台特定配置

答案:B

解析:只有当不同平台确实需要特殊配置时,才使用 expect/actual。如果只是选择一个能工作的引擎,使用 ktor-client-engine-defaults 即可。

第二组:HttpClient配置与插件(4题)

第5题 在Ktor的HttpClient配置中,HttpRequestRetry 和 HttpTimeout 的正确安装顺序是( )

A. HttpTimeout 在前,HttpRequestRetry 在后 B. HttpRequestRetry 在前,HttpTimeout 在后 C. 顺序不影响功能 D. 两者不能同时安装

答案:B

解析:HttpRequestRetry 必须在 HttpTimeout 之前安装,以便为超时配置重试策略。如果先安装 HttpTimeout,重试策略可能无法正确感知超时事件。

第6题 以下哪个不是HttpClient必须配置的插件?( )

A. ContentNegotiation B. HttpTimeout C. SSE(Server-Sent Events) D. DefaultRequest

答案:C

解析:SSE插件仅在需要服务器推送事件的场景中使用,不是网络层的必备插件。ContentNegotiation(JSON序列化)、HttpTimeout(超时控制)、DefaultRequest(基础URL和通用头)是标准配置。

第7题 ktor-client-engine-defaults 引入后,在 commonMain 中创建 HttpClient 的方式是( )

A. HttpClient(OkHttp) B. HttpClient(Darwin) C. HttpClient()(无需指定引擎) D. HttpClient(CIO)

答案:C

解析:ktor-client-engine-defaults 使 HttpClient() 无需指定引擎参数。Ktor会自动为每个目标选择适当的可用引擎。

第8题 以下关于 HttpClient 生命周期的说法,正确的是( )

A. 每次请求都创建新的 HttpClient B. HttpClient 是重量级对象,应作为单例管理 C. HttpClient 不能通过依赖注入管理 D. 每个ViewModel创建独立的 HttpClient

答案:B

解析:HttpClient 是重量级对象,包含连接池、线程池等资源,应作为单例管理。通常通过Koin等依赖注入框架提供单例实例。

第三组:认证与拦截器(4题)

第9题 Ktor的Auth插件中,refreshTokens 块用于( )

A. 首次加载Token B. 在Token过期时刷新Token并重新发送原请求 C. 清除Token D. 验证Token格式

答案:B

解析:refreshTokens 块在服务端返回401时被触发,负责刷新Token并重新发送原请求。loadTokens 块用于首次加载Token。

第10题 当多个请求同时因401失败时,Ktor的行为是( )

A. 每个请求都执行一次刷新 B. 客户端仅执行一次令牌刷新,第一个收到401的请求触发 refreshTokens C. 所有请求都失败 D. 随机选择一个请求执行刷新

答案:B

解析:当多个请求同时因401 Unauthorized失败时,客户端仅执行一次令牌刷新。第一个收到401响应的请求会触发 refreshTokens 回调。

第11题 Ktor 3.6.0引入的类型安全认证能力不包括以下哪项?( )

A. 类型化API保证复杂认证场景的类型安全 B. OpenID Connect(OIDC)插件支持 C. 基于角色的访问控制 D. 自动生成认证Token

答案:D

解析:Ktor 3.6.0的类型安全认证引入了类型化API、OpenID Connect插件、角色访问控制和匿名用户支持。它不会自动生成认证Token。

第12题 HttpRequestRetry 的 exponentialDelay() 配置的作用是( )

A. 立即重试 B. 使用指数退避算法计算重试间隔 C. 固定间隔重试 D. 禁用重试

答案:B

解析:exponentialDelay() 使用指数退避算法计算重试间隔,避免在服务端压力大时频繁重试造成雪崩效应。

第四组:Repository模式与错误处理(3题)

第13题 Repository模式中,Repository的职责边界不包括( )

A. 决定数据来自Remote还是Local B. 管理缓存和同步策略 C. 配置Authorization Header和HttpTimeout D. 暴露干净的领域模型方法

答案:C

解析:Repository关心的是数据来源决策、缓存管理和同步策略。它不应该关心Authorization Header、HttpTimeout、Ktor Plugin、引擎配置等底层网络细节。

第14题 safeApiCall 中为什么必须重新抛出 CancellationException?( )

A. 因为编译器要求 B. 否则协程取消会被误当作网络错误处理,破坏结构化并发 C. 为了提高性能 D. 为了兼容iOS平台

答案:B

解析:CancellationException 是协程取消的信号,不是网络错误。如果被 catch (e: Exception) 捕获并转换为AppError,协程的取消机制会被破坏,导致协程泄漏或不正确的状态更新。

第15题 在KMP项目中使用 MockEngine 时,以下哪种做法是正确的?( )

A. 使用顶层属性定义HttpClient B. 将 MockEngine 通过构造函数注入到 HttpClient 中 C. 在平台源集中定义MockEngine D. 不需要MockEngine,直接调用真实API

答案:B

解析:MockEngine 必须通过构造函数注入到 HttpClient 中。如果使用顶层属性定义HttpClient,测试中传入的 MockEngine 不会被使用,测试会尝试连接真实API。

本课知识点总结

1. 引擎抽象与依赖配置

Ktor Client的核心设计是客户端与引擎分离。Android/JVM默认OkHttp,Apple平台默认Darwin(NSURLSession),Linux/Windows默认CIO,Web(Wasm)默认Js(Fetch API)。Ktor 3.6.0引入 ktor-client-engine-defaults,在 commonMain 中一行依赖即可自动选择引擎,消除了平台源集中重复声明引擎的样板代码。仅当需要平台特定配置时才使用 expect/actual。

2. HttpClient配置要点

ContentNegotiation 配合 ktor-serialization-kotlinx-json 处理JSON序列化。HttpRequestRetry 必须在 HttpTimeout 之前安装。HttpClient 应作为单例通过Koin管理。插件链顺序:DefaultRequest → Auth → Logging → HttpRequestRetry → HttpTimeout → Engine。

3. 认证与拦截器

Auth插件的 bearer 认证方式通过 loadTokens 加载初始Token,通过 refreshTokens 在401时刷新并重发请求。刷新请求应使用独立的 refreshClient 避免循环。多个请求同时401时,Ktor仅执行一次刷新。401(认证恢复)和503(瞬时故障恢复)是两种不同的恢复链路。

4. Repository模式与错误处理

网络层遵循 ViewModel → Repository → ApiService → NetworkClient → HttpClient 的分层。Repository负责数据来源决策,不关心Authorization、HttpTimeout等底层细节。safeApiCall 统一处理异常,CancellationException 必须重新抛出。断网和超时映射为不同的 AppError 类型。

5. 网络状态的UI表达

结合密封接口状态建模与ViewModel架构,网络请求状态表达为 isLoading、error、data 三态。UI层根据状态渲染加载指示器、错误内容(含重试按钮)或数据内容。错误提示应根据 AppError 类型呈现不同的用户友好文案。

6. 跨平台注意事项与测试策略

断网预检查应区分Internet连通性和局域网连通性。iOS的Darwin引擎需要注意后台网络挂起问题。Wasm平台受浏览器同源策略约束,需要服务端配置CORS。测试使用 ktor-client-mock 的 MockEngine,必须通过构造函数注入到 HttpClient 中,不能使用顶层属性。共享与下沉的边界:业务网络规则共享,真正的平台差异下沉。

7. Ktor 3.6.0新特性速览

类型安全认证(类型化API保证复杂认证场景的类型安全)、OpenID Connect(OIDC)插件(自动发现和配置)、Netty HTTP/3实验性支持、ktor-client-engine-defaults 多平台默认引擎、ContentNegotiation的 SkipIfPresent 合并策略(保留显式Accept头)。

下一课预告:第14课将深入平台互操作——在Compose中嵌入原生视图,包括Android端 AndroidView 嵌入传统View组件、iOS端 UIKitView 和 UIKitViewController 嵌入SwiftUI/UIKit视图、Desktop端 SwingPanel 嵌入Swing组件、互操作视图的自动调整大小、混合UI策略(全共享UI、部分共享UI、逐步采用路径),以及Swift/Objective-C调用共享Kotlin代码的实践要点。