Kotlin + Spring Boot 深度指南

public class User {
    private Long id;
    private String name;
    private String email;

    public User(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public boolean equals(Object o) { /* ... */ }
    @Override
    public int hashCode() { /* ... */ }
    @Override
    public String toString() { /* ... */ }
}

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

// 编译错误：不能将 null 赋给非空类型
var name: String = null // Error!

// 显式声明可空
var name: String? = null // OK

// 安全调用链
val length = user?.address?.city?.length

// Elvis 操作符
val displayName = user?.name ?: "Anonymous"

// 非空断言（谨慎使用）
val length = name!!.length // 如果 name 为 null，抛出 NPE

// 为 String 添加转换方法
fun String.toSlug(): String =
    lowercase().replace(" ", "-").replace(Regex("[^a-z0-9-]"), "")

// 使用
"Hello World!".toSlug() // "hello-world"

// Spring 提供的扩展函数
import org.springframework.data.repository.findByIdOrNull

val user = repository.findByIdOrNull(id) // 返回 User? 而非 Optional<User>

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    sealed class Failure : ApiResult<Nothing>() {
        data class NotFound(val message: String) : Failure()
        data class ValidationError(val errors: List<String>) : Failure()
        data class ServerError(val cause: Throwable) : Failure()
    }
}

// 编译器强制穷举匹配 --- 漏掉任何分支都会报错
fun handleResult(result: ApiResult<User>): ResponseEntity<*> =
    when (result) {
        is ApiResult.Success -> ResponseEntity.ok(result.data)
        is ApiResult.Failure.NotFound -> ResponseEntity.notFound().build()
        is ApiResult.Failure.ValidationError -> ResponseEntity.badRequest().body(result.errors)
        is ApiResult.Failure.ServerError -> ResponseEntity.internalServerError().build()
    }

// let：空安全 + 转换
val dto = user?.let { UserDto(it.name, it.email) }

// apply：对象初始化
val user = User().apply {
    name = "Alice"
    email = "alice@example.com"
    role = Role.ADMIN
}

// also：附加操作（如日志）
return repository.save(entity).also {
    logger.info("Created user: ${it.id}")
}

// Spring Security DSL
http {
    authorizeHttpRequests {
        authorize("/api/public/**", permitAll)
        authorize(anyRequest, authenticated)
    }
    oauth2ResourceServer { jwt { } }
}

// Spring Bean Definition DSL
val myBeans = beans {
    bean<UserService>()
    bean { OrderService(ref(), ref()) }
    profile("prod") { bean<ProdDataSource>() }
}

// coRouter DSL（协程路由）
coRouter {
    "/api/users".nest {
        GET("", handler::findAll)
        GET("/{id}", handler::findById)
        POST("", handler::create)
    }
}

// Spring 接口标注了 @NullMarked，返回类型默认非空
// 标注 @Nullable 的方法在 Kotlin 中返回可空类型

// 以前（Spring Boot 3.x）--- 平台类型，可能 NPE
val user: User! = repository.findById(1).orElse(null)

// 现在（Spring Boot 4.0）--- 编译器知道可空性
val user: User? = repository.findByIdOrNull(1) // 明确可空

@Serializable
data class UserDto(
    val id: Long,
    val name: String,
    val email: String
)

// 标注 @Serializable 的类自动使用 kotlinx.serialization
// 未标注的类仍使用 Jackson（Actuator 等仍需 Jackson）

import org.springframework.security.config.annotation.web.invoke // 关键 import！

@Configuration
@EnableWebSecurity
class SecurityConfig {

    @Bean
    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
        http {
            authorizeHttpRequests {
                authorize("/api/public/**", permitAll)
                authorize("/api/admin/**", hasRole("ADMIN"))
                authorize(anyRequest, authenticated)
            }
            httpBasic { }
            csrf { disable() }
            cors { }
        }
        return http.build()
    }

    @Bean
    fun userDetailsService(): UserDetailsService {
        val user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build()
        return InMemoryUserDetailsManager(user)
    }
}

@RestController
@RequestMapping("/api/users")
class UserController(private val service: UserService) {

    // suspend 函数 --- 返回单个结果
    @GetMapping("/{id}")
    suspend fun getUser(@PathVariable id: Long): User =
        service.findById(id) ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)

    // Flow --- 返回流式结果
    @GetMapping
    fun getAllUsers(): Flow<User> = service.findAll()

    // 并行调用 --- 结构化并发
    @GetMapping("/{id}/profile")
    suspend fun getUserProfile(@PathVariable id: Long): UserProfile = coroutineScope {
        val user = async { service.findById(id) }
        val orders = async { service.getOrders(id) }
        val stats = async { service.getStats(id) }
        UserProfile(
            user = user.await() ?: throw ResponseStatusException(HttpStatus.NOT_FOUND),
            orders = orders.await(),
            stats = stats.await()
        )
    }
}

// coroutineScope：任何子协程失败，所有子协程取消
suspend fun fetchAllData(): CombinedData = coroutineScope {
    val users = async { fetchUsers() }    // 并行
    val orders = async { fetchOrders() }  // 并行
    CombinedData(users.await(), orders.await())
    // 如果 fetchUsers 抛异常，fetchOrders 自动取消
}

// supervisorScope：子协程失败互不影响
suspend fun fetchBestEffort(): PartialData = supervisorScope {
    val users = async { fetchUsers() }
    val orders = async { fetchOrders() }
    PartialData(
        users = runCatching { users.await() }.getOrDefault(emptyList()),
        orders = runCatching { orders.await() }.getOrDefault(emptyList())
    )
}

import kotlinx.coroutines.reactor.asFlux
import kotlinx.coroutines.reactive.asFlow

// Flow -> Flux
val flux: Flux<User> = flow.asFlux()

// Flux -> Flow
val flow: Flow<User> = flux.asFlow()

// 错误：Data Class 的 equals/hashCode 基于所有属性
// 自增 ID 在 persist 前后变化，会破坏 HashSet/HashMap
data class User(
    @Id @GeneratedValue val id: Long = 0, // 危险！
    val name: String
)

// 正确：使用普通 class
@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long? = null,

    @Column(nullable = false)
    var name: String,

    @Column(nullable = false, unique = true)
    var email: String
)

// 同步（Spring MVC）
@Repository
interface UserRepository : JpaRepository<User, Long> {
    fun findByEmail(email: String): User?
    fun findByNameContaining(name: String): List<User>
}

// 协程（Spring WebFlux + R2DBC）
@Repository
interface UserRepository : CoroutineCrudRepository<User, Long> {
    fun findByLastName(lastName: String): Flow<User>
}

import org.springframework.data.repository.findByIdOrNull

val user: User? = repository.findByIdOrNull(id)

plugins {
    id("org.springframework.boot") version "4.0.2"
    id("io.spring.dependency-management") version "1.1.7"
    kotlin("jvm") version "2.2.21"
    kotlin("plugin.spring") version "2.2.21"
    kotlin("plugin.jpa") version "2.2.21"
    kotlin("plugin.serialization") version "2.2.21"
}

group = "com.example"
version = "0.0.1-SNAPSHOT"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-security")
    implementation("org.springframework.boot:spring-boot-starter-validation")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")

    // 协程
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")

    // kotlinx.serialization（Spring Boot 4.0）
    implementation("org.springframework.boot:spring-boot-starter-kotlin-serialization")

    runtimeOnly("com.h2database:h2")
    runtimeOnly("org.postgresql:postgresql")

    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("io.mockk:mockk:1.13.16")
    testImplementation("com.ninja-squad:springmockk:4.0.2")
}

allOpen {
    annotation("jakarta.persistence.Entity")
    annotation("jakarta.persistence.MappedSuperclass")
    annotation("jakarta.persistence.Embeddable")
}

kotlin {
    compilerOptions {
        freeCompilerArgs.addAll("-Xjsr305=strict")
    }
}

tasks.withType<Test> {
    useJUnitPlatform()
}

src/main/kotlin/com/example/app/
    Application.kt
    config/             # SecurityConfig, WebConfig 等
    controller/         # REST 控制器
    service/            # 业务逻辑
    repository/         # 数据访问
    model/
        entity/         # JPA 实体
        dto/            # 数据传输对象
    extension/          # Kotlin 扩展函数
    exception/          # 自定义异常、全局错误处理

src/main/kotlin/com/example/app/
    user/
        UserController.kt
        UserService.kt
        UserRepository.kt
        User.kt
    order/
        OrderController.kt
        OrderService.kt
        ...

@ExtendWith(MockKExtension::class)
class UserServiceTest {

    @MockK
    lateinit var repository: UserRepository

    @InjectMockKs
    lateinit var service: UserService

    @Test
    fun `should find user by id`() {
        // Given
        val user = User(1, "Alice", "alice@test.com")
        every { repository.findByIdOrNull(1) } returns user

        // When
        val result = service.findById(1)

        // Then
        result shouldBe user
        verify(exactly = 1) { repository.findByIdOrNull(1) }
    }

    @Test
    fun `should return null when user not found`() {
        every { repository.findByIdOrNull(999) } returns null

        service.findById(999) shouldBe null
    }
}

@Test
fun `should fetch user profile with parallel calls`() = runTest {
    coEvery { userRepository.findByIdOrNull(1) } returns mockUser
    coEvery { orderClient.getOrders(1) } returns listOf(mockOrder)
    coEvery { statsClient.getStats(1) } returns mockStats

    val profile = service.getUserProfile(1)

    profile.user shouldBe mockUser
    profile.orders shouldHaveSize 1
    coVerify { userRepository.findByIdOrNull(1) }
}

// K2 改进的智能类型转换
fun process(value: Any) {
    if (value is String && value.length > 0) {
        // K2 在更多场景下自动推断 value 为 String
        println(value.uppercase())
    }
}

// when 表达式守卫条件
sealed class Animal {
    data class Cat(val name: String, val moulesPerDay: Int) : Animal()
    data class Dog(val name: String) : Animal()
}

fun feedAnimal(animal: Animal) {
    when (animal) {
        is Animal.Cat if animal.moulesPerDay > 2 -> println("Fat cat!")
        is Animal.Cat -> println("Normal cat")
        is Animal.Dog -> println("Good dog")
    }
}

// 非局部 break/continue
fun processItems(items: List<String>) {
    for (item in items) {
        item.let {
            if (it == "skip") continue  // Kotlin 2.1 支持
            println(it)
        }
    }
}