모던 Kotlin 2026 — Kotlin 2.1 / K2 컴파일러 / Compose Multiplatform / KMP 2.1 / Ktor 3 / Spring Boot Kotlin 심층 가이드

                +----------------------------------------+
                |             Kotlin 2.2.x               |
                |  (K2 compiler default, JVM/JS/Wasm)    |
                +----------------------------------------+
                              |
          +-------------------+--------------------+
          |                   |                    |
          v                   v                    v
   [JVM 백엔드]          [멀티플랫폼]         [Native / Wasm]
   Spring Boot 3.5     KMP 2.1 + CMP 1.7      Kotlin/Native
   Ktor 3              iOS/Android/Desktop    Kotlin/Wasm
   gRPC-Kotlin         Web (Wasm)             (Ktor 3 server)
          |                   |                    |
          +-------------------+--------------------+
                              |
                              v
                  +-------------------------+
                  | kotlinx 라이브러리 진영  |
                  | coroutines / Flow       |
                  | serialization / io      |
                  | datetime / atomicfu     |
                  +-------------------------+
                              |
                              v
              +---------------+----------------+
              |               |                |
              v               v                v
         [DI/FP/ORM]     [정적분석/테스트]   [빌드]
         Koin / Arrow    Detekt / Konsist    Gradle Kotlin DSL
         Exposed         Kotest / MockK      Maven Kotlin plugin

// Kotlin 2.1: $$ 안에서는 단일 $는 리터럴, $$는 보간 시작
val template = $$"""
    Hello, $$name!
    Your balance is $1000 (USD).
    JSON: {"value": "$$value"}
"""

sealed interface Order
data class Pending(val amount: Int) : Order
data class Paid(val amount: Int, val txId: String) : Order

fun handle(order: Order) = when (order) {
    is Pending if order.amount > 10_000 -> "high-value pending"
    is Pending -> "pending"
    is Paid -> "paid: ${order.txId}"
}

// 기존: 매번 명시적으로 logger를 받아야
fun calculate(x: Int, y: Int, logger: Logger): Int {
    logger.info("calc $x + $y")
    return x + y
}

// 또는 클래스로 묶기
class Calculator(private val logger: Logger) {
    fun calculate(x: Int, y: Int): Int { ... }
}

// Kotlin 2.2 context parameters
context(logger: Logger)
fun calculate(x: Int, y: Int): Int {
    logger.info("calc $x + $y")
    return x + y
}

// 호출 측: Logger를 scope에 띄워두면 자동 주입
fun main() {
    with(MyLogger()) {
        val result = calculate(1, 2)  // logger 명시 X
    }
}

import arrow.core.raise.Raise

context(raise: Raise<String>)
fun parsePositive(s: String): Int {
    val n = s.toIntOrNull() ?: raise.raise("not a number: $s")
    if (n <= 0) raise.raise("must be positive: $n")
    return n
}

// 호출 측
fun main() {
    val result = either {
        val n = parsePositive("42")
        n * 2
    }
    // result: Either.Right(84)
}

fun process(value: Any?) {
    if (value is String || value is Int) {
        // K1: value는 여전히 Any?
        // K2: value는 String | Int (intersection)
        println(value.hashCode())  // K2는 정상 호출
    }
}

class Holder {
    val data: List<Int>
    init {
        val tmp = mutableListOf<Int>()
        tmp.add(1); tmp.add(2)
        data = tmp.toList()  // K2: 정상
    }
}

// commonMain/HelloApp.kt
@Composable
fun HelloApp(name: String) {
    MaterialTheme {
        Column(modifier = Modifier.padding(16.dp)) {
            Text("Hello, $name!", style = MaterialTheme.typography.headlineSmall)
            Spacer(Modifier.height(8.dp))
            Button(onClick = { /* ... */ }) {
                Text("Tap me")
            }
        }
    }
}

// commonMain
expect fun platformName(): String

// androidMain
actual fun platformName(): String = "Android ${Build.VERSION.RELEASE}"

// iosMain
actual fun platformName(): String =
    UIDevice.currentDevice.systemName + " " + UIDevice.currentDevice.systemVersion

shared/
  build.gradle.kts
  src/
    commonMain/kotlin/    <- 모든 플랫폼 공통 코드
    androidMain/kotlin/   <- Android-only
    iosMain/kotlin/       <- iOS-only (Kotlin/Native)
    jvmMain/kotlin/       <- JVM 서버용
    wasmJsMain/kotlin/    <- Wasm 웹용
    commonTest/kotlin/    <- 공통 테스트

// shared/build.gradle.kts
kotlin {
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    cocoapods {
        version = "1.0"
        summary = "Shared module for MyApp"
        homepage = "https://example.com"
        ios.deploymentTarget = "15.0"
        framework {
            baseName = "Shared"
            isStatic = false
        }
    }
}

./gradlew :shared:podPublishXcFramework
# 결과물을 Xcode 프로젝트의 Podfile에 추가

import Shared

let repo = UserRepository()
Task {
    let users = try await repo.fetchUsers()
    print(users)
}

// build.gradle.kts
plugins {
    kotlin("jvm") version "2.1.0"
    application
}
dependencies {
    implementation("io.ktor:ktor-server-core:3.0.0")
    implementation("io.ktor:ktor-server-cio:3.0.0")
    implementation("io.ktor:ktor-server-content-negotiation:3.0.0")
    implementation("io.ktor:ktor-serialization-kotlinx-json:3.0.0")
}

// src/main/kotlin/Application.kt
import io.ktor.serialization.kotlinx.json.json
import io.ktor.server.application.install
import io.ktor.server.cio.CIO
import io.ktor.server.engine.embeddedServer
import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
import io.ktor.server.response.respond
import io.ktor.server.routing.get
import io.ktor.server.routing.routing
import kotlinx.serialization.Serializable

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

fun main() {
    embeddedServer(CIO, port = 8080) {
        install(ContentNegotiation) { json() }
        routing {
            get("/users") {
                call.respond(listOf(User(1, "Alice"), User(2, "Bob")))
            }
        }
    }.start(wait = true)
}

@RestController
class UserController(private val repo: UserRepository) {
    @GetMapping("/users/{id}")
    suspend fun getUser(@PathVariable id: Long): UserDto =
        repo.findById(id)?.toDto() ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)

    @GetMapping("/users", produces = [MediaType.APPLICATION_NDJSON_VALUE])
    fun streamUsers(): Flow<UserDto> =
        repo.findAll().map { it.toDto() }
}

interface UserRepository : CoroutineCrudRepository<UserEntity, Long> {
    suspend fun findByEmail(email: String): UserEntity?

    @Query("SELECT * FROM users WHERE created_at > :since")
    fun findRecentUsers(since: Instant): Flow<UserEntity>
}

@Configuration
class AppConfig {
    @Bean
    fun routes(handler: UserHandler) = coRouter {
        accept(MediaType.APPLICATION_JSON).nest {
            GET("/users", handler::list)
            POST("/users", handler::create)
        }
    }

    @Bean
    fun securityFilter(http: ServerHttpSecurity): SecurityWebFilterChain =
        http {
            authorizeExchange {
                authorize("/public/**", permitAll)
                authorize(anyExchange, authenticated)
            }
            oauth2ResourceServer { jwt {} }
        }
}

import kotlinx.coroutines.*

suspend fun fetchUser(id: Long): User { /* HTTP 호출 */ }
suspend fun fetchOrders(userId: Long): List<Order> { /* HTTP 호출 */ }

suspend fun loadProfile(id: Long): Profile = coroutineScope {
    val userDeferred = async { fetchUser(id) }
    val ordersDeferred = async { fetchOrders(id) }
    Profile(userDeferred.await(), ordersDeferred.await())
}

fun userUpdates(userId: Long): Flow<UserEvent> = flow {
    while (currentCoroutineContext().isActive) {
        val event = pollEvent(userId)
        if (event != null) emit(event)
        delay(1000)
    }
}

// 소비
suspend fun watchUser() {
    userUpdates(42L)
        .filter { it.type == EventType.UPDATED }
        .map { it.toDto() }
        .take(10)
        .collect { println(it) }
}

class UserViewModel(private val repo: UserRepository) {
    private val _state = MutableStateFlow<UserState>(UserState.Loading)
    val state: StateFlow<UserState> = _state.asStateFlow()

    fun load(id: Long) {
        viewModelScope.launch {
            _state.value = UserState.Loading
            _state.value = runCatching { repo.findById(id) }
                .fold(
                    onSuccess = { UserState.Loaded(it) },
                    onFailure = { UserState.Error(it.message ?: "") }
                )
        }
    }
}

// build.gradle.kts
plugins {
    id("io.gitlab.arturbosch.detekt") version "1.23.7"
}

detekt {
    toolVersion = "1.23.7"
    config.setFrom("$rootDir/detekt.yml")
    buildUponDefaultConfig = true
}

complexity:
  CyclomaticComplexMethod:
    threshold: 15
  LongMethod:
    threshold: 60
naming:
  FunctionNaming:
    functionPattern: '[a-z][a-zA-Z0-9]*'
style:
  MagicNumber:
    ignoreNumbers: ['-1', '0', '1', '2']

./gradlew detekt
# 결과: build/reports/detekt/detekt.html

// src/test/kotlin/ArchitectureTest.kt
import com.lemonappdev.konsist.api.Konsist
import com.lemonappdev.konsist.api.verify.assertTrue

class ArchitectureTest {
    @Test
    fun `repositories should not depend on controllers`() {
        Konsist.scopeFromProject()
            .classes()
            .withNameEndingWith("Repository")
            .assertTrue { repo ->
                repo.containingFile.imports
                    .none { it.name.contains("controller") }
            }
    }

    @Test
    fun `all use cases end with UseCase`() {
        Konsist.scopeFromPackage("..usecase..")
            .classes()
            .assertTrue { it.name.endsWith("UseCase") }
    }
}

val appModule = module {
    single<UserRepository> { UserRepositoryImpl(get()) }
    single<HttpClient> {
        HttpClient(CIO) {
            install(ContentNegotiation) { json() }
        }
    }
    viewModel { UserViewModel(get()) }
}

fun main() {
    startKoin {
        modules(appModule)
    }
    // ...
}

import arrow.core.Either
import arrow.core.raise.either

sealed interface UserError {
    object NotFound : UserError
    data class Invalid(val reason: String) : UserError
}

fun parseAge(s: String): Either<UserError, Int> = either {
    val n = s.toIntOrNull() ?: raise(UserError.Invalid("not a number: $s"))
    if (n < 0 || n > 150) raise(UserError.Invalid("age out of range: $n"))
    n
}

fun loadUser(id: Long): Either<UserError, User> = either {
    val user = repo.find(id) ?: raise(UserError.NotFound)
    user
}

fun process(id: Long, ageStr: String): Either<UserError, Result> = either {
    val user = loadUser(id).bind()
    val age = parseAge(ageStr).bind()
    Result(user, age)
}

object Users : LongIdTable("users") {
    val name = varchar("name", 100)
    val email = varchar("email", 200).uniqueIndex()
    val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
}

transaction {
    val newId = Users.insertAndGetId {
        it[name] = "Alice"
        it[email] = "alice@example.com"
    }

    val users = Users
        .selectAll()
        .where { Users.name like "A%" }
        .orderBy(Users.createdAt to SortOrder.DESC)
        .limit(10)
        .map { it[Users.name] to it[Users.email] }
}

class UserSpec : StringSpec({
    "user with valid email should be created" {
        val u = User("alice@example.com")
        u.isValid shouldBe true
    }

    "negative age should throw" {
        shouldThrow<IllegalArgumentException> {
            User("a@b", age = -1)
        }
    }
})

class PropertySpec : StringSpec({
    "reverse twice is identity" {
        checkAll<List<Int>> { list ->
            list.reversed().reversed() shouldBe list
        }
    }
})

class UserServiceTest : StringSpec({
    val repo = mockk<UserRepository>()
    val service = UserService(repo)

    "should return user from repo" {
        coEvery { repo.findById(1L) } returns User(1, "Alice")

        val u = service.getUser(1L)
        u.name shouldBe "Alice"

        coVerify(exactly = 1) { repo.findById(1L) }
    }
})

plugins {
    kotlin("jvm") version "2.1.0"
    kotlin("plugin.serialization") version "2.1.0"
    application
}

group = "com.example"
version = "0.1.0"

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
    testImplementation(kotlin("test"))
    testImplementation("io.kotest:kotest-runner-junit5:5.9.1")
}

application {
    mainClass.set("com.example.AppKt")
}

kotlin {
    jvmToolchain(21)
}

tasks.test {
    useJUnitPlatform()
}

[versions]
kotlin = "2.1.0"
coroutines = "1.9.0"
ktor = "3.0.0"

[libraries]
kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
ktor-server-core = { module = "io.ktor:ktor-server-core", version.ref = "ktor" }
ktor-server-cio = { module = "io.ktor:ktor-server-cio", version.ref = "ktor" }

[plugins]
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
ktor = { id = "io.ktor.plugin", version.ref = "ktor" }

plugins {
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.ktor)
}
dependencies {
    implementation(libs.ktor.server.core)
    implementation(libs.ktor.server.cio)
    implementation(libs.kotlinx.coroutines)
}

# gradle.properties
org.gradle.configuration-cache=true
org.gradle.caching=true
org.gradle.parallel=true
kotlin.incremental=true
kotlin.code.style=official

<plugin>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-maven-plugin</artifactId>
    <version>2.1.0</version>
    <configuration>
        <jvmTarget>21</jvmTarget>
        <compilerPlugins>
            <plugin>spring</plugin>
            <plugin>jpa</plugin>
        </compilerPlugins>
    </configuration>
</plugin>