使用 Kotlin Multiplatform 构建全栈应用程序
代码示例: full-stack-task-manager
所用插件:Routing路由是处理服务器应用程序中传入请求的核心插件。、 kotlinx.serialization、 Content NegotiationContentNegotiation 插件有两个主要用途:在客户端和服务器之间协商媒体类型,以及以特定格式序列化/反序列化内容。、 Compose Multiplatform、 Kotlin Multiplatform
在本文中,您将学习如何使用 Kotlin 开发一个可在 Android、iOS、Web 和桌面平台上运行的全栈应用程序,同时利用 Ktor 实现无缝的数据处理。
学完本教程后,您将掌握以下内容:
- 使用 Kotlin Multiplatform 创建全栈应用程序。
- 理解使用 IntelliJ IDEA 生成的项目。
- 创建调用 Ktor 服务的 Compose Multiplatform 客户端。
- 在设计的不同层之间复用共享类型。
- 正确引入并配置多平台库。
在之前的教程中,我们使用任务管理器(Task Manager)示例来 处理请求通过构建一个任务管理器应用程序,学习在 Kotlin 中使用 Ktor 处理路由、请求和形参的基础知识。、 创建 RESTful API了解如何使用 Kotlin 和 Ktor 构建后端服务,并包含一个生成 JSON 文件的 RESTful API 示例。以及 通过 Exposed 集成数据库了解使用 Exposed SQL 库将 Ktor 服务连接到数据库仓库的过程。。客户端应用程序保持了最简实现,以便您可以专注于学习 Ktor 的基础知识。
您将创建一个面向 Android、iOS、Web 和桌面平台的客户端,使用 Ktor 服务获取要显示的数据。只要可能,您都将在客户端和服务器之间共享数据类型,从而加快开发速度并减少潜在错误。
先决条件
与之前的文章一样,您将使用 IntelliJ IDEA 作为 IDE。要安装并配置您的环境,请参阅 Kotlin Multiplatform 快速入门 。
如果这是您第一次使用 Compose Multiplatform,建议您在开始本教程之前先完成 Compose Multiplatform 入门 教程。为了降低任务的复杂度,您可以专注于单一客户端平台。例如,如果您从未使用过 iOS,那么专注于桌面或 Android 开发可能是明智的选择。
创建新项目
与其使用 Ktor 项目生成器,不如使用 IntelliJ IDEA 中的 Kotlin Multiplatform 项目向导。它将创建一个基础的多平台项目,您可以向其中扩展客户端和服务。客户端可以使用原生 UI 库(例如 SwiftUI),但在本教程中,您将使用 Compose Multiplatform 为所有平台创建共享 UI。
- 启动 IntelliJ IDEA。
- 在 IntelliJ IDEA 中,选择 File | New | Project 。
- 在左侧面板中,选择 Kotlin Multiplatform 。
- 在 New Project 窗口中指定以下字段:
- Name : full-stack-task-manager
- Project ID : com.example.ktor
选择 Android 、 Desktop 、 Web 和 Server 作为目标平台。
如果您使用的是 Mac,请一并选择 iOS 。确保已勾选 Share UI 选项。

点击 Create 按钮,等待 IDE 生成并导入项目。
运行服务
- 在 IntelliJ IDEA 中,选择 ApplicationKt 运行配置。

- 点击 Run 按钮 (
) 以运行配置。
Run 工具窗口中将打开一个新标签页。
访问 http://0.0.0.0:8080/ 打开应用程序。您应该会在浏览器中看到来自 Ktor 的显示消息。

查看项目结构
server 文件夹是项目中的三个 Kotlin 模块之一。另外两个是 core 和 app 。
server 模块的结构与 Ktor 项目生成器生成的结构非常相似。您有一个专门用于声明插件和依赖项的构建文件,以及一个包含构建和启动 Ktor 服务代码的源集:

如果查看 Application.kt 文件中的路由指令,您将看到对 sayHello() 函数的调用:
fun Application.module() {
routing {
get("/") {
call.respondText(sayHello("Ktor"))
}
}
}sayHello() 函数定义在 core 模块中。您可以在这里存放要在服务器和所有不同客户端平台之间共享的公共代码。
打开 app/shared/src/commonMain 模块中的 Greeting.kt 文件,可以看到 sayHello() 函数在那里也被使用了:
class Greeting {
private val platform = getPlatform()
fun greet(): String {
return sayHello(platform.name)
}
}app 模块包含以下子模块:
- androidApp、desktopApp、iosApp 和 webApp 子模块分别包含 Android、Desktop、iOS 和 Web 客户端应用的平台专有代码。目前这些客户端应用都尚未连接到 Ktor 服务。
shared 子模块包含要在其上提供客户端的各个平台的源集。这是因为在 commonMain 中声明的类型所需的功能因目标平台而异。
例如,在
Greeting类型中,当前平台的名称是通过平台特定 API 获取的,采用了期望声明和实际声明机制。在 shared 子模块的 commonMain 源集中,
getPlatform()函数使用expect关键字声明:kotlinpackage com.example.ktor interface Platform { val name: String } expect fun getPlatform(): Platform然后,每个目标平台都提供
getPlatform()函数的actual声明,如下所示:kotlinpackage com.example.ktor import platform.UIKit.UIDevice class IOSPlatform : Platform { override val name: String = UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion } actual fun getPlatform(): Platform = IOSPlatform()kotlinpackage com.example.ktor import android.os.Build class AndroidPlatform : Platform { override val name: String = "Android ${Build.VERSION.SDK_INT}" } actual fun getPlatform(): Platform = AndroidPlatform()kotlinpackage com.example.ktor class JVMPlatform : Platform { override val name: String = "Java ${System.getProperty("java.version")}" } actual fun getPlatform(): Platform = JVMPlatform()kotlinpackage com.example.ktor class WasmPlatform : Platform { override val name: String = "Web with Kotlin/Wasm" } actual fun getPlatform(): Platform = WasmPlatform()
运行客户端应用程序
您可以通过执行对应目标的运行配置来运行客户端应用程序。要在 iOS 模拟器上运行该应用程序,请按照以下步骤操作:
- 在 IntelliJ IDEA 中,选择 iosApp 运行配置和模拟设备。

- 点击 Run 按钮 (
) 以运行配置。
当您运行 iOS 应用时,它在底层由 Xcode 构建并在 iOS 模拟器中启动。该应用显示一个按钮,点击后会切换显示一张图片。

首次按下按钮时,当前平台的详细信息会被添加到其文本中。实现此功能的代码位于 app/shared/src/commonMain/kotlin/com/example/ktor/App.kt :
kotlin@Composable @Preview fun App() { MaterialTheme { var showContent by remember { mutableStateOf(false) } Column( modifier = Modifier .background(MaterialTheme.colorScheme.primaryContainer) .safeContentPadding() .fillMaxSize(), horizontalAlignment = Alignment.CenterHorizontally, ) { Button(onClick = { showContent = !showContent }) { Text("Click me!") } AnimatedVisibility(showContent) { val greeting = remember { Greeting().greet() } Column( modifier = Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally, ) { Image(painterResource(Res.drawable.compose_multiplatform), null) Text("Compose: $greeting") } } } } }这是一个 composable 函数,您将在本文稍后部分对其进行修改。目前,唯一重要的是它显示了一个 UI,并使用了共享的
Greeting类型,而该类型又使用了实现通用Platform接口的平台专有类。
现在您已经了解了生成的项目结构,可以逐步添加任务管理器功能。
添加模型类型
首先,添加模型类型并确保客户端和服务端都可以访问它们。
- 前往 gradle/libs.versions.toml 并定义以下
kotlinx.serialization依赖项:toml[versions] kotlinx-serialization-json = "1.11.0" [libraries] kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization-json" } [plugins] kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } 前往 core/build.gradle.kts 并添加序列化插件:
kotlinplugins { //... alias(libs.plugins.kotlinSerialization) }在同一个文件中,向 commonMain 源集添加一个新依赖项:
kotlinsourceSets { commonMain.dependencies { // put your Multiplatform dependencies here implementation(libs.kotlinx.serialization.json) } //... }- 在 IntelliJ IDEA 中,选择 Build | Sync Project with Gradle Files 以应用更新。Gradle 导入完成后,您应该会发现 Task.kt 文件可以成功编译。
- 前往 core/src/commonMain/kotlin/com/example/ktor 并创建一个名为 model 的新软件包。
- 在新建的软件包内,创建一个名为 Task.kt 的新文件。
添加一个表示优先级的枚举和一个表示任务的类。
Task类使用来自kotlinx.serialization库的Serializable类型进行注解:kotlinpackage com.example.ktor.model import kotlinx.serialization.Serializable enum class Priority { Low, Medium, High, Vital } @Serializable data class Task( val name: String, val description: String, val priority: Priority )
创建服务器
下一步是创建任务管理器的服务器实现。
- 前往 server/src/main/kotlin/com/example/ktor 文件夹并创建一个名为 model 的子软件包。
在该软件包中,创建一个新的 TaskRepository.kt 文件并为仓库添加以下接口:
kotlinpackage com.example.ktor.model interface TaskRepository { fun allTasks(): List<Task> fun tasksByPriority(priority: Priority): List<Task> fun taskByName(name: String): Task? fun addOrUpdateTask(task: Task) fun removeTask(name: String): Boolean }在同一个软件包中,创建一个包含以下类的新文件 InMemoryTaskRepository.kt :
kotlinpackage com.example.ktor.model class InMemoryTaskRepository : TaskRepository { private var tasks = listOf( Task("Cleaning", "Clean the house", Priority.Low), Task("Gardening", "Mow the lawn", Priority.Medium), Task("Shopping", "Buy the groceries", Priority.High), Task("Painting", "Paint the fence", Priority.Low), Task("Cooking", "Cook the dinner", Priority.Medium), Task("Relaxing", "Take a walk", Priority.High), Task("Exercising", "Go to the gym", Priority.Low), Task("Learning", "Read a book", Priority.Medium), Task("Snoozing", "Go for a nap", Priority.High), Task("Socializing", "Go to a party", Priority.High) ) override fun allTasks(): List<Task> = tasks override fun tasksByPriority(priority: Priority) = tasks.filter { it.priority == priority } override fun taskByName(name: String) = tasks.find { it.name.equals(name, ignoreCase = true) } override fun addOrUpdateTask(task: Task) { var notFound = true tasks = tasks.map { if (it.name == task.name) { notFound = false task } else { it } } if (notFound) { tasks = tasks.plus(task) } } override fun removeTask(name: String): Boolean { val oldTasks = tasks tasks = tasks.filterNot { it.name == name } return oldTasks.size > tasks.size } }前往 server/src/main/kotlin/.../Application.kt 并将现有代码替换为以下实现:
kotlinpackage com.example.ktor import com.example.ktor.model.InMemoryTaskRepository import com.example.ktor.model.Priority import com.example.ktor.model.Task import io.ktor.http.* import io.ktor.serialization.* import io.ktor.serialization.kotlinx.json.* import io.ktor.server.application.* import io.ktor.server.engine.* import io.ktor.server.netty.* import io.ktor.server.plugins.contentnegotiation.* import io.ktor.server.plugins.cors.routing.* import io.ktor.server.request.* import io.ktor.server.response.* import io.ktor.server.routing.* fun main() { embeddedServer(Netty, port = 8080, host = "0.0.0.0", module = Application::module) .start(wait = true) } fun Application.module() { install(ContentNegotiation) { json() } install(CORS) { allowHeader(HttpHeaders.ContentType) allowMethod(HttpMethod.Delete) // For ease of demonstration we allow any connections. // Don't do this in production. anyHost() } val repository = InMemoryTaskRepository() routing { route("/tasks") { get { val tasks = repository.allTasks() call.respond(tasks) } get("/byName/{taskName}") { val name = call.parameters["taskName"] if (name == null) { call.respond(HttpStatusCode.BadRequest) return@get } val task = repository.taskByName(name) if (task == null) { call.respond(HttpStatusCode.NotFound) return@get } call.respond(task) } get("/byPriority/{priority}") { val priorityAsText = call.parameters["priority"] if (priorityAsText == null) { call.respond(HttpStatusCode.BadRequest) return@get } try { val priority = Priority.valueOf(priorityAsText) val tasks = repository.tasksByPriority(priority) if (tasks.isEmpty()) { call.respond(HttpStatusCode.NotFound) return@get } call.respond(tasks) } catch (ex: IllegalArgumentException) { call.respond(HttpStatusCode.BadRequest) } } post { try { val task = call.receive<Task>() repository.addOrUpdateTask(task) call.respond(HttpStatusCode.NoContent) } catch (ex: IllegalStateException) { call.respond(HttpStatusCode.BadRequest) } catch (ex: JsonConvertException) { call.respond(HttpStatusCode.BadRequest) } } delete("/{taskName}") { val name = call.parameters["taskName"] if (name == null) { call.respond(HttpStatusCode.BadRequest) return@delete } if (repository.removeTask(name)) { call.respond(HttpStatusCode.NoContent) } else { call.respond(HttpStatusCode.NotFound) } } } } }该实现与之前教程中的实现非常相似,不同之处在于,为了简化起见,现在您已将所有路由代码放置在
Application.module()函数中。输入此代码并添加导入后,您会发现多个编译器错误,因为代码使用了多个需要作为依赖项引入的 Ktor 插件,包括用于与 Web 客户端交互的 CORS必需依赖项:io.ktor:ktor-server-cors 插件。
- 打开 settings.gradle.kts 并导入 Ktor 版本目录: kotlin
dependencyResolutionManagement { versionCatalogs { create("ktorLibs").from("io.ktor:ktor-version-catalog:3.6.1") } } 打开服务器模块构建文件( server/build.gradle.kts )并添加以下依赖项:
kotlindependencies { //... implementation(ktorLibs.serialization.kotlinx.json) implementation(ktorLibs.server.contentNegotiation) implementation(ktorLibs.server.cors) }- 再次在主菜单中选择 Build | Sync Project with Gradle Files。导入完成后,您应该会发现
ContentNegotiation类型和json()函数的导入可以正常工作。 - 重新运行服务器。您应该会发现可以通过浏览器访问这些路由。
创建客户端
为了让您的客户端能够访问服务器,您需要引入 Ktor Client。这涉及三种类型的依赖项:
- Ktor Client 的核心功能。
- 处理网络连接的平台专有引擎。
- 对内容协商和序列化的支持。
- 前往 app/shared/build.gradle.kts 并添加以下依赖项: kotlin
kotlin { //... sourceSets { androidMain.dependencies { //... implementation(ktorLibs.client.android) } commonMain.dependencies { //... implementation(ktorLibs.client.core) implementation(ktorLibs.client.contentNegotiation) implementation(ktorLibs.serialization.kotlinx.json) } jvmMain.dependencies { implementation(ktorLibs.client.cio) } iosMain.dependencies { implementation(ktorLibs.client.darwin) } wasmJsMain.dependencies { implementation(ktorLibs.client.js) } } }完成此操作后,您可以为客户端添加一个
TaskApi类型,作为 Ktor Client 的轻量封装器。 - 在主菜单中选择 Build | Sync Project with Gradle Files 以导入构建文件中的更改。
- 前往 app/shared/src/commonMain/kotlin/com/example/ktor 并创建一个名为 network 的新软件包。
在新软件包内,创建一个新的 HttpClientManager.kt 文件用于客户端配置:
kotlinpackage com.example.ktor.network import io.ktor.client.HttpClient import io.ktor.client.plugins.contentnegotiation.ContentNegotiation import io.ktor.client.plugins.defaultRequest import io.ktor.serialization.kotlinx.json.json import kotlinx.serialization.json.Json fun createHttpClient() = HttpClient { install(ContentNegotiation) { json(Json { encodeDefaults = true isLenient = true coerceInputValues = true ignoreUnknownKeys = true }) } defaultRequest { host = "1.2.3.4" // Replace with the IP address of your current machine. port = 8080 } }将
1.2.3.4替换为您当前计算机的 IP 地址。在 Android 虚拟设备或 iOS 模拟器上运行的代码无法直接调用0.0.0.0或localhost。查找您的 IP 地址:
由于移动模拟器无法访问
localhost,您需要计算机的实际 IP 地址。若要查找您的 IP 地址,请运行以下命令之一:- macOS:
ifconfig | grep "inet " | grep -v 127.0.0.1 - Linux:
hostname -I | awk '{print $1}' - Windows:
ipconfig并查找“IPv4 地址”
- macOS:
在同一个 app/shared/.../network 软件包中,创建一个包含以下实现的 TaskApi.kt 文件:
kotlinpackage com.example.ktor.network import com.example.ktor.model.Task import io.ktor.client.HttpClient import io.ktor.client.call.body import io.ktor.client.request.delete import io.ktor.client.request.get import io.ktor.client.request.post import io.ktor.client.request.setBody import io.ktor.http.ContentType import io.ktor.http.contentType class TaskApi(private val httpClient: HttpClient) { suspend fun getAllTasks(): List<Task> { return httpClient.get("tasks").body() } suspend fun removeTask(task: Task) { httpClient.delete("tasks/${task.name}") } suspend fun updateTask(task: Task) { httpClient.post("tasks") { contentType(ContentType.Application.Json) setBody(task) } } }前往 app/shared/.../App.kt 并将代码替换为以下实现。 这将使用
TaskApi类型从服务器检索任务列表,然后在单列中显示每个任务的名称:kotlinpackage com.example.ktor import com.example.ktor.network.TaskApi import com.example.ktor.network.createHttpClient import com.example.ktor.model.Task import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.safeContentPadding import androidx.compose.material3.Button import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import kotlinx.coroutines.launch @Composable fun App() { MaterialTheme { val httpClient = createHttpClient() val taskApi = remember { TaskApi(httpClient) } val tasks = remember { mutableStateOf(emptyList<Task>()) } val scope = rememberCoroutineScope() Column( modifier = Modifier .safeContentPadding() .fillMaxSize(), horizontalAlignment = Alignment.CenterHorizontally, ) { Button(onClick = { scope.launch { tasks.value = taskApi.getAllTasks() } }) { Text("Fetch Tasks") } for (task in tasks.value) { Text(task.name) } } } }在服务器运行的同时,通过运行 iosApp 运行配置来测试 iOS 应用程序。
点击 Fetch Tasks 按钮以显示任务列表:
在此演示中,为了清晰起见我们简化了流程。在实际应用中,避免通过网络发送未加密数据至关重要。在 Android 平台上,您需要显式授予应用程序网络权限,并允许其以明文形式发送和接收数据。若要启用这些权限,请打开 app/androidApp/src/main/AndroidManifest.xml 并添加以下设置:
xml<manifest> ... <application android:usesCleartextTraffic="true"> ... ... </application> <uses-permission android:name="android.permission.INTERNET"/> </manifest>使用 app.androidApp 运行配置运行 Android 应用程序。您现在应该会发现 Android 客户端也能够正常运行:

对于桌面客户端,您需要为包含它的窗口指定尺寸和标题。打开文件 app/desktopApp/src/.../main.kt 并通过修改
title和设置state属性来调整代码:kotlinpackage com.example.ktor import androidx.compose.ui.unit.DpSize import androidx.compose.ui.unit.dp import androidx.compose.ui.window.Window import androidx.compose.ui.window.WindowPosition import androidx.compose.ui.window.WindowState import androidx.compose.ui.window.application fun main() = application { val state = WindowState( size = DpSize(400.dp, 600.dp), position = WindowPosition(200.dp, 100.dp) ) Window( title = "Task Manager (Desktop)", state = state, onCloseRequest = ::exitApplication, ) { App() } }使用 app [hot] 🔥 运行配置运行桌面应用程序:

使用以下运行配置之一运行 Web 客户端:
- app [js]:运行 Kotlin/JS 应用程序。
- app [wasmJs]:运行 Kotlin/Wasm 应用程序。

改进 UI
客户端现在已经可以与服务器通信,但这谈不上是一个美观的 UI。
打开位于 app/shared/src/commonMain/.../ktor 中的 App.kt 文件,并将现有的
App替换为以下App和TaskCardcomposable:fun App() { {...}
kotlinpackage com.example.ktor import com.example.ktor.network.TaskApi import com.example.ktor.model.Priority import com.example.ktor.model.Task import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.safeContentPadding import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items import androidx.compose.foundation.shape.CornerSize import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.Card import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedButton import androidx.compose.material3.Text import androidx.compose.runtime.* import androidx.compose.ui.Modifier import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import com.example.ktor.network.createHttpClient import kotlinx.coroutines.launch @Composable fun App() { MaterialTheme { val httpClient = createHttpClient() val taskApi = remember { TaskApi(httpClient) } var tasks by remember { mutableStateOf(emptyList<Task>()) } val scope = rememberCoroutineScope() LaunchedEffect(Unit) { tasks = taskApi.getAllTasks() } LazyColumn( modifier = Modifier .safeContentPadding() .fillMaxSize() ) { items(tasks) { task -> TaskCard( task, onDelete = { scope.launch { taskApi.removeTask(it) tasks = taskApi.getAllTasks() } }, onUpdate = { } ) } } } } @Composable fun TaskCard( task: Task, onDelete: (Task) -> Unit, onUpdate: (Task) -> Unit ) { fun pickWeight(priority: Priority) = when (priority) { Priority.Low -> FontWeight.SemiBold Priority.Medium -> FontWeight.Bold Priority.High, Priority.Vital -> FontWeight.ExtraBold } Card( modifier = Modifier.fillMaxWidth().padding(4.dp), shape = RoundedCornerShape(CornerSize(4.dp)) ) { Column(modifier = Modifier.padding(10.dp)) { Text( "${task.name}: ${task.description}", fontSize = 20.sp, fontWeight = pickWeight(task.priority) ) Row { OutlinedButton(onClick = { onDelete(task) }) { Text("Delete") } Spacer(Modifier.width(8.dp)) OutlinedButton(onClick = { onUpdate(task) }) { Text("Update") } } } } }通过这个实现,您的客户端现在具备了一些基本功能。
通过使用
LaunchedEffect类型,所有任务都会在启动时加载,而LazyColumncomposable 则允许用户滚动浏览任务。最后,创建了一个单独的
TaskCardcomposable,它使用Card来显示每个Task的详细信息。此外还添加了用于删除和更新任务的按钮。重新运行客户端应用程序——例如 Android 应用。您现在可以滚动浏览任务、查看详细信息并删除它们:

添加更新功能
要完善客户端,请加入允许更新任务详情的功能。
- 前往 app/shared/src/commonMain/.../ktor 中的 App.kt 文件。
添加
UpdateTaskDialogcomposable 和必要的导入,如下所示:kotlinimport androidx.compose.material3.TextField import androidx.compose.material3.TextFieldDefaults import androidx.compose.ui.graphics.Color import androidx.compose.ui.window.Dialog @Composable fun UpdateTaskDialog( task: Task, onConfirm: (Task) -> Unit ) { var description by remember { mutableStateOf(task.description) } var priorityText by remember { mutableStateOf(task.priority.toString()) } val colors = TextFieldDefaults.colors( focusedTextColor = Color.Blue, focusedContainerColor = Color.White, ) Dialog(onDismissRequest = {}) { Card( modifier = Modifier.fillMaxWidth().padding(4.dp), shape = RoundedCornerShape(CornerSize(4.dp)) ) { Column(modifier = Modifier.padding(10.dp)) { Text("Update ${task.name}", fontSize = 20.sp) TextField( value = description, onValueChange = { description = it }, label = { Text("Description") }, colors = colors ) TextField( value = priorityText, onValueChange = { priorityText = it }, label = { Text("Priority") }, colors = colors ) OutlinedButton(onClick = { val newTask = Task( task.name, description, try { Priority.valueOf(priorityText) } catch (e: IllegalArgumentException) { Priority.Low } ) onConfirm(newTask) }) { Text("Update") } } } } }这是一个使用对话框显示
Task详细信息的 composable。description和priority被放置在TextFieldcomposable 中,以便进行更新。当用户按下更新按钮时,会触发onConfirm()回调。更新同一文件中的
Appcomposable:kotlin@Composable fun App() { MaterialTheme { val httpClient = createHttpClient() val taskApi = remember { TaskApi(httpClient) } var tasks by remember { mutableStateOf(emptyList<Task>()) } val scope = rememberCoroutineScope() var currentTask by remember { mutableStateOf<Task?>(null) } LaunchedEffect(Unit) { tasks = taskApi.getAllTasks() } if (currentTask != null) { UpdateTaskDialog( currentTask!!, onConfirm = { scope.launch { taskApi.updateTask(it) tasks = taskApi.getAllTasks() } currentTask = null } ) } LazyColumn(modifier = Modifier .safeContentPadding() .fillMaxSize() ) { items(tasks) { task -> TaskCard( task, onDelete = { scope.launch { taskApi.removeTask(it) tasks = taskApi.getAllTasks() } }, onUpdate = { currentTask = task } ) } } } }您存储了一个额外的状态片段,即当前选中的任务。如果该值不为 null,则调用我们的
UpdateTaskDialogcomposable,并将onConfirm()回调设置为使用TaskApi向服务器发送 POST 请求。最后,在创建
TaskCardcomposable 时,使用onUpdate()回调来设置currentTask状态变量。- 重新运行客户端应用程序。您现在应该能够使用按钮更新每个任务的详细信息。

后续步骤
在本文中,您在 Kotlin Multiplatform 应用程序的上下文中使用了 Ktor。现在,您可以创建一个包含多个服务和客户端并面向一系列不同平台的项目。
正如您所见,在构建功能时可以做到没有任何代码重复或冗余。项目所有层所需的类型都可以放置在 core 多平台模块中。仅服务所需的功能放在 server 模块中,而仅客户端所需的功能则放在 app 模块中。
这种开发方式不可避免地需要同时掌握客户端和服务器端技术的知识。但是,您可以使用 Kotlin Multiplatform 库和 Compose Multiplatform 来尽量减少需要学习的新知识。即使您最初只专注于单一平台,随着对应用程序需求的增长,也可以轻松添加其他平台。

