Skip to content

使用 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。

  1. 启动 IntelliJ IDEA。
  2. 在 IntelliJ IDEA 中,选择 File | New | Project 。
  3. 在左侧面板中,选择 Kotlin Multiplatform 。
  4. 在 New Project 窗口中指定以下字段:
    • Name : full-stack-task-manager
    • Project ID : com.example.ktor
  5. 选择 Android 、 Desktop 、 Web 和 Server 作为目标平台。

  6. 如果您使用的是 Mac,请一并选择 iOS 。确保已勾选 Share UI 选项。 Kotlin Multiplatform 向导设置

  7. 点击 Create 按钮,等待 IDE 生成并导入项目。

运行服务

  1. 在 IntelliJ IDEA 中,选择 ApplicationKt 运行配置。 运行/调试窗口
  2. 点击 Run 按钮 (IntelliJ IDEA 运行图标) 以运行配置。

    Run 工具窗口中将打开一个新标签页。

  3. 访问 http://0.0.0.0:8080/ 打开应用程序。您应该会在浏览器中看到来自 Ktor 的显示消息。 Ktor 服务器浏览器响应

查看项目结构

server 文件夹是项目中的三个 Kotlin 模块之一。另外两个是 core 和 app 。

server 模块的结构与 Ktor 项目生成器生成的结构非常相似。您有一个专门用于声明插件和依赖项的构建文件,以及一个包含构建和启动 Ktor 服务代码的源集:

Kotlin Multiplatform 项目中 server 文件夹的内容

如果查看 Application.kt 文件中的路由指令,您将看到对 sayHello() 函数的调用:

kotlin
fun Application.module() {
    routing {
        get("/") {
            call.respondText(sayHello("Ktor"))
        }
    }
}

sayHello() 函数定义在 core 模块中。您可以在这里存放要在服务器和所有不同客户端平台之间共享的公共代码。

打开 app/shared/src/commonMain 模块中的 Greeting.kt 文件,可以看到 sayHello() 函数在那里也被使用了:

kotlin
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 关键字声明:

    kotlin
    package com.example.ktor
    
    interface Platform {
        val name: String
    }
    
    expect fun getPlatform(): Platform

    然后,每个目标平台都提供 getPlatform() 函数的 actual 声明,如下所示:

    kotlin
    package 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()
    kotlin
    package com.example.ktor
    
    import android.os.Build
    
    class AndroidPlatform : Platform {
        override val name: String = "Android ${Build.VERSION.SDK_INT}"
    }
    
    actual fun getPlatform(): Platform = AndroidPlatform()
    kotlin
    package com.example.ktor
    
    class JVMPlatform : Platform {
        override val name: String = "Java ${System.getProperty("java.version")}"
    }
    
    actual fun getPlatform(): Platform = JVMPlatform()
    kotlin
    package com.example.ktor
    
    class WasmPlatform : Platform {
        override val name: String = "Web with Kotlin/Wasm"
    }
    
    actual fun getPlatform(): Platform = WasmPlatform()

运行客户端应用程序

您可以通过执行对应目标的运行配置来运行客户端应用程序。要在 iOS 模拟器上运行该应用程序,请按照以下步骤操作:

  1. 在 IntelliJ IDEA 中,选择 iosApp 运行配置和模拟设备。 运行/调试窗口
  2. 点击 Run 按钮 (IntelliJ IDEA 运行图标) 以运行配置。
  3. 当您运行 iOS 应用时,它在底层由 Xcode 构建并在 iOS 模拟器中启动。该应用显示一个按钮,点击后会切换显示一张图片。 在 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 接口的平台专有类。

现在您已经了解了生成的项目结构,可以逐步添加任务管理器功能。

添加模型类型

首先,添加模型类型并确保客户端和服务端都可以访问它们。

  1. 前往 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" }
  2. 前往 core/build.gradle.kts 并添加序列化插件:

    kotlin
    plugins {
        //...
        alias(libs.plugins.kotlinSerialization)
    }
  3. 在同一个文件中,向 commonMain 源集添加一个新依赖项:

    kotlin
    sourceSets {
        commonMain.dependencies {
            // put your Multiplatform dependencies here
            implementation(libs.kotlinx.serialization.json)
        }
        //...
    }
  4. 在 IntelliJ IDEA 中,选择 Build | Sync Project with Gradle Files 以应用更新。Gradle 导入完成后,您应该会发现 Task.kt 文件可以成功编译。
  5. 前往 core/src/commonMain/kotlin/com/example/ktor 并创建一个名为 model 的新软件包。
  6. 在新建的软件包内,创建一个名为 Task.kt 的新文件。
  7. 添加一个表示优先级的枚举和一个表示任务的类。Task 类使用来自 kotlinx.serialization 库的 Serializable 类型进行注解:

    kotlin
    package 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
    )

创建服务器

下一步是创建任务管理器的服务器实现。

  1. 前往 server/src/main/kotlin/com/example/ktor 文件夹并创建一个名为 model 的子软件包。
  2. 在该软件包中,创建一个新的 TaskRepository.kt 文件并为仓库添加以下接口:

    kotlin
    package 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
    }
  3. 在同一个软件包中,创建一个包含以下类的新文件 InMemoryTaskRepository.kt :

    kotlin
    package 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
        }
    }
  4. 前往 server/src/main/kotlin/.../Application.kt 并将现有代码替换为以下实现:

    kotlin
    package 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 插件。

  5. 打开 settings.gradle.kts 并导入 Ktor 版本目录:
    kotlin
    dependencyResolutionManagement {
        versionCatalogs {
            create("ktorLibs").from("io.ktor:ktor-version-catalog:3.6.1")
        }
    }
  6. 打开服务器模块构建文件( server/build.gradle.kts )并添加以下依赖项:

    kotlin
    dependencies {
        //...
        implementation(ktorLibs.serialization.kotlinx.json)
        implementation(ktorLibs.server.contentNegotiation)
        implementation(ktorLibs.server.cors)
    }
  7. 再次在主菜单中选择 Build | Sync Project with Gradle Files。导入完成后,您应该会发现 ContentNegotiation 类型和 json() 函数的导入可以正常工作。
  8. 重新运行服务器。您应该会发现可以通过浏览器访问这些路由。
  9. 访问 和 以查看以 JSON 格式返回任务的服务器响应。 浏览器中的服务器响应

创建客户端

为了让您的客户端能够访问服务器,您需要引入 Ktor Client。这涉及三种类型的依赖项:

  • Ktor Client 的核心功能。
  • 处理网络连接的平台专有引擎。
  • 对内容协商和序列化的支持。
  1. 前往 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 的轻量封装器。

  2. 在主菜单中选择 Build | Sync Project with Gradle Files 以导入构建文件中的更改。
  3. 前往 app/shared/src/commonMain/kotlin/com/example/ktor 并创建一个名为 network 的新软件包。
  4. 在新软件包内,创建一个新的 HttpClientManager.kt 文件用于客户端配置:

    kotlin
    package 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 地址”
  5. 在同一个 app/shared/.../network 软件包中,创建一个包含以下实现的 TaskApi.kt 文件:

    kotlin
    package 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)
            }
        }
    }
  6. 前往 app/shared/.../App.kt 并将代码替换为以下实现。 这将使用 TaskApi 类型从服务器检索任务列表,然后在单列中显示每个任务的名称:

    kotlin
    package 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)
                }
            }
        }
    }
  7. 在服务器运行的同时,通过运行 iosApp 运行配置来测试 iOS 应用程序。

  8. 点击 Fetch Tasks 按钮以显示任务列表: 在 iOS 上运行的应用

    在此演示中,为了清晰起见我们简化了流程。在实际应用中,避免通过网络发送未加密数据至关重要。
  9. 在 Android 平台上,您需要显式授予应用程序网络权限,并允许其以明文形式发送和接收数据。若要启用这些权限,请打开 app/androidApp/src/main/AndroidManifest.xml 并添加以下设置:

    xml
    <manifest>
        ...
        <application
                android:usesCleartextTraffic="true">
        ...
        ...
        </application>
        <uses-permission android:name="android.permission.INTERNET"/>
    </manifest>
  10. 使用 app.androidApp 运行配置运行 Android 应用程序。您现在应该会发现 Android 客户端也能够正常运行: 在 Android 上运行的应用

  11. 对于桌面客户端,您需要为包含它的窗口指定尺寸和标题。打开文件 app/desktopApp/src/.../main.kt 并通过修改 title 和设置 state 属性来调整代码:

    kotlin
    package 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()
        }
    }
  12. 使用 app [hot] 🔥 运行配置运行桌面应用程序: 在桌面平台上运行的应用

  13. 使用以下运行配置之一运行 Web 客户端:

    • app [js]:运行 Kotlin/JS 应用程序。
    • app [wasmJs]:运行 Kotlin/Wasm 应用程序。
    在 Web 上运行的应用

改进 UI

客户端现在已经可以与服务器通信,但这谈不上是一个美观的 UI。

  1. 打开位于 app/shared/src/commonMain/.../ktor 中的 App.kt 文件,并将现有的 App 替换为以下 App 和 TaskCard composable:

    fun App() { {...}
    kotlin
    package 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 类型,所有任务都会在启动时加载,而 LazyColumn composable 则允许用户滚动浏览任务。

    最后,创建了一个单独的 TaskCard composable,它使用 Card 来显示每个 Task 的详细信息。此外还添加了用于删除和更新任务的按钮。

  2. 重新运行客户端应用程序——例如 Android 应用。您现在可以滚动浏览任务、查看详细信息并删除它们: 在 Android 上运行带有改进 UI 的应用

添加更新功能

要完善客户端,请加入允许更新任务详情的功能。

  1. 前往 app/shared/src/commonMain/.../ktor 中的 App.kt 文件。
  2. 添加 UpdateTaskDialog composable 和必要的导入,如下所示:

    kotlin
    import 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 被放置在 TextField composable 中,以便进行更新。当用户按下更新按钮时,会触发 onConfirm() 回调。

  3. 更新同一文件中的 App composable:

    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,则调用我们的 UpdateTaskDialog composable,并将 onConfirm() 回调设置为使用 TaskApi 向服务器发送 POST 请求。

    最后,在创建 TaskCard composable 时,使用 onUpdate() 回调来设置 currentTask 状态变量。

  4. 重新运行客户端应用程序。您现在应该能够使用按钮更新每个任务的详细信息。 在 Android 上删除任务

后续步骤

在本文中,您在 Kotlin Multiplatform 应用程序的上下文中使用了 Ktor。现在,您可以创建一个包含多个服务和客户端并面向一系列不同平台的项目。

正如您所见,在构建功能时可以做到没有任何代码重复或冗余。项目所有层所需的类型都可以放置在 core 多平台模块中。仅服务所需的功能放在 server 模块中,而仅客户端所需的功能则放在 app 模块中。

这种开发方式不可避免地需要同时掌握客户端和服务器端技术的知识。但是,您可以使用 Kotlin Multiplatform 库和 Compose Multiplatform 来尽量减少需要学习的新知识。即使您最初只专注于单一平台,随着对应用程序需求的增长,也可以轻松添加其他平台。