Java 개발자를 위한 Kotlin: NPE 종말과 코루틴 혁명

// Kotlin: Non-null 타입 (기본)
var name: String = "Alice"
// name = null  // ❌ 컴파일 에러!

// Kotlin: Nullable 타입 (? 붙임)
var nullableName: String? = "Alice"
nullableName = null  // ✅ 가능

val user: User? = findUser(id)

// 1. Safe Call (?.)
val city = user?.address?.city  // null이면 전파, NPE 없음

// 2. Elvis Operator (?:)
val cityName = user?.address?.city ?: "Unknown"  // null이면 기본값

// 3. Not-null Assertion (!!) — 최후의 수단
val forceCity = user!!.address.city  // null이면 NPE 발생! 가급적 쓰지 마세요

// 4. Safe Cast (as?)
val str: String? = value as? String  // 캐스팅 실패 시 null

// 5. let과 조합 — Null이 아닐 때만 실행
user?.let { u ->
    println("${u.name}은(는) ${u.address?.city}에 살고 있습니다")
}

// Java: 방어 코드 지옥
String city = "Unknown";
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String c = address.getCity();
        if (c != null) {
            city = c;
        }
    }
}

// Kotlin: 한 줄
val city = user?.address?.city ?: "Unknown"

// Kotlin
data class User(val name: String, val age: Int)

val user = User("Alice", 25)

// copy: 불변 객체 변형
val older = user.copy(age = 26)  // User(name=Alice, age=26)

// 구조 분해 (Destructuring)
val (name, age) = user
println("$name is $age years old")  // Alice is 25 years old

// Map에서 구조 분해
mapOf("a" to 1, "b" to 2).forEach { (key, value) ->
    println("$key = $value")
}

// let: Null 체크 + 변환
val length: Int? = name?.let { it.trim().length }

// apply: 객체 초기화 (Builder 대체)
val config = HttpClient().apply {
    connectTimeout = Duration.ofSeconds(5)
    readTimeout = Duration.ofSeconds(10)
    followRedirects = true
}

// also: 부수 효과 (체이닝 중간에 로깅)
val user = userRepository.findById(id)
    .also { log.debug("Found user: $it") }
    .orElseThrow { UserNotFoundException(id) }

// run: 객체 컨텍스트에서 계산
val greeting = user.run {
    "안녕하세요, ${name}님! ${age}세이시군요."
}

// with: Non-null 객체의 다중 호출
with(StringBuilder()) {
    append("Hello, ")
    append(user.name)
    append("!")
    toString()  // 반환
}

Null 체크 필요?
  └─ Yes → let
  └─ No → 반환값이 객체 자체?
            └─ Yes → apply (설정) / also (로깅/검증)
            └─ No  → run / with

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    data class Error(val code: Int, val message: String) : ApiResult<Nothing>()
    data object Loading : ApiResult<Nothing>()
}

// when: else가 필요 없음! 컴파일러가 모든 케이스 커버를 강제
fun <T> handleResult(result: ApiResult<T>): String = when (result) {
    is ApiResult.Success -> "Data: ${result.data}"
    is ApiResult.Error   -> "Error ${result.code}: ${result.message}"
    is ApiResult.Loading -> "Loading..."
    // 새 하위 타입 추가 시 → 여기서 컴파일 에러 발생! 누락 방지
}

sealed class OrderEvent {
    data class Created(val orderId: Long, val items: List<Item>) : OrderEvent()
    data class Paid(val orderId: Long, val amount: Money) : OrderEvent()
    data class Shipped(val orderId: Long, val trackingNo: String) : OrderEvent()
    data class Cancelled(val orderId: Long, val reason: String) : OrderEvent()
}

fun processEvent(event: OrderEvent) = when (event) {
    is OrderEvent.Created   -> inventoryService.reserve(event.items)
    is OrderEvent.Paid      -> paymentService.confirm(event.amount)
    is OrderEvent.Shipped   -> notificationService.sendTracking(event.trackingNo)
    is OrderEvent.Cancelled -> inventoryService.release(event.orderId)
}

// 10만 개 코루틴 — 문제 없음
runBlocking {
    repeat(100_000) {
        launch {
            delay(1000)
            print(".")
        }
    }
}
// Thread로 같은 걸 하면? → OutOfMemoryError 💥

// suspend 함수: "여기서 잠시 멈출 수 있어요"
suspend fun fetchUser(id: Long): User {
    // 네트워크 호출 중 스레드를 점유하지 않음!
    return httpClient.get("https://api.example.com/users/$id")
}

// 호출 코드: 동기처럼 보이지만 비동기로 동작
suspend fun getUserProfile(id: Long): Profile {
    val user = fetchUser(id)            // 네트워크 대기
    val orders = fetchOrders(user.id)    // 네트워크 대기
    return Profile(user, orders)
}

suspend fun loadDashboard(): Dashboard = coroutineScope {
    // 두 작업을 병렬로 실행
    val userDeferred = async { fetchUser(userId) }
    val ordersDeferred = async { fetchOrders(userId) }
    
    // 둘 다 완료될 때까지 대기
    Dashboard(
        user = userDeferred.await(),
        orders = ordersDeferred.await()
    )
    // 하나가 실패하면? → 다른 하나도 자동 취소!
}

suspend fun processData() {
    withContext(Dispatchers.IO) {
        // DB 조회 (IO 스레드)
        val data = repository.findAll()
    }
    withContext(Dispatchers.Default) {
        // 무거운 계산 (CPU 스레드)
        data.map { transform(it) }
    }
}

// String 클래스에 기능 추가
fun String.lastChar(): Char = this[this.length - 1]

println("Kotlin".lastChar())  // 'n'

// 실무: 도메인 확장
fun Money.toKRW(): String = "₩${String.format("%,.0f", this.amount)}"

val price = Money(15000.0)
println(price.toKRW())  // ₩15,000

// ❌ Java 스타일: 유틸 클래스
object StringUtils {
    fun isEmail(s: String): Boolean = s.matches(EMAIL_REGEX)
}
StringUtils.isEmail(input)

// ✅ Kotlin 스타일: 확장 함수
fun String.isEmail(): Boolean = matches(EMAIL_REGEX)
input.isEmail()  // 더 자연스러움

// 1. open 문제: Spring은 CGLIB 프록시로 클래스를 상속하는데,
//    Kotlin 클래스는 기본이 final
// 해결: kotlin-spring 플러그인 (자동으로 open 처리)

// build.gradle.kts
plugins {
    kotlin("plugin.spring") version "2.0.0"  // 필수!
    kotlin("plugin.jpa") version "2.0.0"     // JPA 엔티티용
}

// 2. JPA 엔티티: no-arg 생성자 필요
// kotlin-jpa 플러그인이 자동으로 no-arg 생성자 추가

@Entity
data class User(
    @Id @GeneratedValue
    val id: Long = 0,      // 기본값으로 no-arg 대응
    val name: String,
    val email: String
)

@RestController
@RequestMapping("/api/users")
class UserController(
    private val userService: UserService  // 생성자 주입 (자동)
) {
    @GetMapping("/{id}")
    suspend fun getUser(@PathVariable id: Long): ResponseEntity<User> {
        val user = userService.findById(id)
            ?: return ResponseEntity.notFound().build()
        return ResponseEntity.ok(user)
    }
    
    @PostMapping
    suspend fun createUser(@Valid @RequestBody request: CreateUserRequest): ResponseEntity<User> {
        val user = userService.create(request)
        return ResponseEntity.status(CREATED).body(user)
    }
}

// Mono/Flux 방식 (리액티브 스트림)
fun findById(id: Long): Mono<User> = ...

// Coroutine 방식 (더 읽기 쉬움)
suspend fun findById(id: Long): User? = ...
fun findAll(): Flow<User> = ...  // Flow = 코루틴 버전 Flux

// 1. Java interop: Platform Type
val result: String = javaMethod()  // Java 반환값은 String! (Platform Type)
// null이 올 수 있는데 Non-null로 받으면 → 런타임 NPE!
// 해결: nullable로 받기
val result: String? = javaMethod()

// 2. data class + JPA: equals/hashCode 주의
// JPA의 지연 로딩 프록시에서 문제 발생 가능
// 해결: id만으로 equals/hashCode 정의
@Entity
class User(
    @Id @GeneratedValue val id: Long = 0,
    var name: String
) {
    override fun equals(other: Any?) = other is User && id == other.id
    override fun hashCode() = id.hashCode()
}

// 3. companion object ≠ static
class MyService {
    companion object {
        private val log = LoggerFactory.getLogger(MyService::class.java)
        // Java에서 접근: MyService.Companion.getLog() 😱
        // 해결: @JvmStatic 어노테이션
    }
}