第12课完成了平台抽象机制的学习。本课进入平台能力与互操作模块的核心实践:Ktor Client的多平台引擎选择与配置、kotlinx.serialization与JSON处理、拦截器与认证的跨平台配置、Repository模式在共享代码中的实现、网络状态的UI表达,以及生产级网络层的完整架构设计。本课内容基于Ktor 3.6.0、kotlinx.serialization 1.9.0与CMP 1.12.1。 文末附有15道配套习题与本课知识点总结。
目录
- 一、为什么选择Ktor:跨平台网络请求的架构决策
- 二、依赖配置与HttpClient创建
- 三、HttpClient的完整配置
- 四、数据模型与JSON序列化
- 五、认证与拦截器
- 六、Repository模式:隔离网络与UI
- 七、网络状态的UI表达
- 八、网络层的跨平台注意事项
- 九、生产级网络架构设计
- 配套习题(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 / JVM | OkHttp | OkHttp |
| iOS / macOS | Darwin | NSURLSession |
| Linux / Windows | CIO | 纯Kotlin协程实现 |
| Web(Wasm) | Js | Fetch API |
Ktor 3.6.0的关键改进:ktor-client-engine-defaults 引入后,在 commonMain 中只需一行依赖声明,即可创建 HttpClient() 而无需选择引擎。Ktor会自动为每个目标选择适当的可用引擎。这消除了此前需要在每个平台源集中重复声明引擎依赖的样板代码。
下面是 Ktor 引擎抽象的整体架构图:
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 的插件链配置流程图:
四、数据模型与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 的重试逻辑。
下面是认证与重试的完整流程图:
六、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 模式的完整分层架构图:
七、网络状态的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/") }
}
}
下面是完整的请求生命周期流程图:
配套习题(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代码的实践要点。