Kotlin + Spring 실전 — 자바 개발자가 코틀린으로 전환할 때 알아야 할 것들

// 코틀린에서 이 클래스는 final
@Service
class UserService { // → CGLIB 프록시 생성 불가!
    @Transactional
    fun createUser(name: String) { /* ... */ }
}

// build.gradle.kts
plugins {
    kotlin("plugin.spring") version "1.9.0" // all-open의 Spring 프리셋
}

// 기본 생성자가 없음 — JPA가 인스턴스를 생성할 수 없음
@Entity
class User(
    @Id @GeneratedValue
    val id: Long,
    val name: String,
    val email: String
)

// build.gradle.kts
plugins {
    kotlin("plugin.jpa") version "1.9.0"
}

// 문제가 되는 코드
@Entity
data class User(
    @Id @GeneratedValue
    val id: Long = 0,
    var name: String = ""
)

val user1 = userRepository.findById(1) // name = "김코틀린"
user1.name = "이코틀린"
val user2 = userRepository.findById(1) // name = "이코틀린"

// data class의 equals는 name도 비교 → 같은 엔티티인데 false
println(user1 == user2) // false

// OneToMany가 LAZY인데 toString()이 강제로 로딩
data class User(
    @OneToMany(fetch = FetchType.LAZY)
    val orders: List<Order> = emptyList()
)

println(user) // orders 접근 → N+1 쿼리 발생

@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,

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

    @Column(nullable = false, unique = true)
    var email: String
) {
    // ID 기반 equals/hashCode
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other !is User) return false
        return id != 0L && id == other.id
    }

    override fun hashCode(): Int = id.hashCode()

    override fun toString(): String = "User(id=$id, name=$name)"
}

// ❌ @NotBlank가 생성자 파라미터에 붙어서 Bean Validation이 동작 안 함
class CreateUserRequest(
    @NotBlank
    val name: String,
    @Email
    val email: String
)

// ✅ @field:를 명시하면 필드에 어노테이션이 붙음
class CreateUserRequest(
    @field:NotBlank
    val name: String,
    @field:Email
    val email: String
)

interface UserRepository : JpaRepository<User, Long> {
    // findById는 Optional<User>을 반환 — 코틀린에서는?
    // Spring Data가 코틀린을 인식하여 nullable로 반환 가능
    fun findByEmail(email: String): User?  // null 가능
    fun findByName(name: String): User     // null이면 예외 발생
}

@GetMapping("/users")
fun searchUsers(
    @RequestParam name: String,        // 필수 파라미터
    @RequestParam email: String? = null // 선택 파라미터 (null 허용, 기본값 null)
): List<User> { /* ... */ }

@RestController
@RequestMapping("/api/users")
class UserController(
    private val userService: UserService
) {
    @GetMapping("/{id}")
    suspend fun getUser(@PathVariable id: Long): UserResponse {
        val user = userService.findById(id) // suspend 함수
        return UserResponse.from(user)
    }

    @GetMapping
    fun getAllUsers(): Flow<UserResponse> { // Flow 반환
        return userService.findAll()
            .map { UserResponse.from(it) }
    }
}

@Service
class UserService(
    private val userRepository: UserCoroutineRepository,
    private val notificationClient: NotificationClient
) {
    suspend fun createUser(request: CreateUserRequest): User {
        val user = User(name = request.name, email = request.email)
        val saved = userRepository.save(user)

        // 비동기로 알림 전송 — 실패해도 사용자 생성은 성공
        coroutineScope {
            launch {
                try {
                    notificationClient.sendWelcome(saved.email)
                } catch (e: Exception) {
                    logger.warn("알림 전송 실패", e)
                }
            }
        }

        return saved
    }
}

interface UserCoroutineRepository : CoroutineCrudRepository<User, Long> {
    suspend fun findByEmail(email: String): User?
    fun findByNameContaining(name: String): Flow<User>
}

// build.gradle.kts
dependencies {
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
}

// 이 data class가 Jackson으로 정상적으로 직렬화/역직렬화됨
data class UserResponse(
    val id: Long,
    val name: String,
    val email: String,
    val createdAt: LocalDateTime = LocalDateTime.now() // 기본값 지원
)

@SpringBootTest
class UserServiceTest @Autowired constructor(
    private val userService: UserService,
    private val userRepository: UserRepository
) {
    @Test
    fun `사용자를 생성하면 DB에 저장된다`() {
        // given
        val request = CreateUserRequest(name = "김코틀린", email = "kotlin@test.com")

        // when
        val user = userService.createUser(request)

        // then
        val found = userRepository.findById(user.id)
        assertThat(found).isNotNull
        assertThat(found!!.name).isEqualTo("김코틀린")
    }
}