[코틀린 마스터하기] 3편: 실전 코틀린 - Spring Boot와 함께!

📚 이 글은 "코틀린 마스터하기" 시리즈의 3편입니다.

• 1편: 자바 개발자가 코틀린 30분만에 정복하기
• 2편: 코틀린의 꽃 - 이것만 알면 생산성 2배!
• 3편: 실전 코틀린 - Spring Boot와 함께! (현재 글)
• 4편: 코틀린 고급 - 코루틴으로 비동기 마스터

🎯 한 줄 요약

Spring Boot 3 + 코틀린으로 10분만에 REST API 서버 완성하기!

🤔 이런 고민 있으신가요?

• "스프링 부트도 코틀린으로 개발 가능한가요?"
• "자바로 된 프로젝트를 코틀린으로 마이그레이션하고 싶어요"
• "코틀린으로 REST API 어떻게 만들죠?"

오늘 이 모든 의문을 해결해드립니다! 🚀

💡 Spring Boot + 코틀린 = 최강 조합!

구글이 안드로이드뿐만 아니라 서버 개발에서도 코틀린을 적극 활용하는 이유가 있습니다.

스프링 공식 문서에서도 코틀린을 First-class 언어로 지원한다고 명시하고 있죠!

🚀 프로젝트 셋업 (5분 완성!)

Step 1: Spring Initializr 접속

start.spring.io 접속 후:

• Project: Gradle - Kotlin
• Language: Kotlin
• Spring Boot: 3.4.x (최신 버전)
• Java: 17 or 21

Step 2: Dependencies 선택

Dependencies:
  - Spring Web
  - Spring Data JPA
  - H2 Database (개발용)
  - Spring Boot DevTools
  - Validation

Step 3: 생성된 build.gradle.kts 확인

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

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

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-validation")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    runtimeOnly("com.h2database:h2")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

자바 프로젝트와 거의 동일하죠? 그냥 언어만 바뀐 것뿐! 😎

💎 1. Entity 클래스 - JPA와 완벽 호환!

자바 방식 (Lombok 필수)

@Entity
@Table(name = "users")
@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    private Integer age;
    
    @CreatedDate
    private LocalDateTime createdAt;
}

코틀린 방식 (깔끔!)

@Entity
@Table(name = "users")
data class User(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,
    
    @Column(nullable = false)
    val name: String,
    
    @Column(unique = true, nullable = false)
    val email: String,
    
    val age: Int? = null,
    
    @CreatedDate
    val createdAt: LocalDateTime = LocalDateTime.now()
)

data class 하나로 끝! Lombok 없이도 모든 기능 자동 생성! 🎉

🔥 2. Repository - 스프링 데이터 JPA 그대로!

@Repository
interface UserRepository : JpaRepository<User, Long> {
    
    fun findByEmail(email: String): User?
    
    fun findByNameContaining(keyword: String): List<User>
    
    fun existsByEmail(email: String): Boolean
    
    // 코틀린 스타일 커스텀 쿼리
    @Query("SELECT u FROM User u WHERE u.age >= :minAge")
    fun findAdultUsers(@Param("minAge") minAge: Int = 18): List<User>
}

자바와 100% 동일! 메서드명 기반 쿼리 생성도 그대로 작동합니다. 👍

⚡ 3. Service 레이어 - 더 간결하게!

자바 서비스

@Service
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    
    public UserDto createUser(CreateUserRequest request) {
        if (userRepository.existsByEmail(request.getEmail())) {
            throw new DuplicateEmailException("Email already exists");
        }
        
        User user = new User();
        user.setName(request.getName());
        user.setEmail(request.getEmail());
        user.setAge(request.getAge());
        
        User savedUser = userRepository.save(user);
        
        return UserDto.builder()
            .id(savedUser.getId())
            .name(savedUser.getName())
            .email(savedUser.getEmail())
            .age(savedUser.getAge())
            .build();
    }
}

코틀린 서비스 (절반!)

@Service
class UserService(
    private val userRepository: UserRepository
) {
    fun createUser(request: CreateUserRequest): UserDto {
        require(!userRepository.existsByEmail(request.email)) {
            "Email already exists"
        }
        
        val user = User(
            name = request.name,
            email = request.email,
            age = request.age
        )
        
        return userRepository.save(user).toDto()
    }
}

// 확장 함수로 변환 로직 분리
fun User.toDto() = UserDto(
    id = id,
    name = name,
    email = email,
    age = age
)

50% 코드 감소! 생성자 주입도 자동, 변환 로직도 확장 함수로 깔끔하게! ✨

🎮 4. REST Controller - 어노테이션 그대로!

@RestController
@RequestMapping("/api/users")
@Validated
class UserController(
    private val userService: UserService
) {
    
    @GetMapping
    fun getAllUsers(): List<UserDto> = 
        userService.getAllUsers()
    
    @GetMapping("/{id}")
    fun getUser(@PathVariable id: Long): UserDto = 
        userService.getUser(id)
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    fun createUser(
        @Valid @RequestBody request: CreateUserRequest
    ): UserDto = userService.createUser(request)
    
    @PutMapping("/{id}")
    fun updateUser(
        @PathVariable id: Long,
        @Valid @RequestBody request: UpdateUserRequest
    ): UserDto = userService.updateUser(id, request)
    
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    fun deleteUser(@PathVariable id: Long) {
        userService.deleteUser(id)
    }
}

스프링 어노테이션 100% 호환! 자바 개발자라면 바로 이해 가능! 🎯

💡 5. DTO와 Validation - 코틀린 스타일!

// Request DTO
data class CreateUserRequest(
    @field:NotBlank(message = "이름은 필수입니다")
    val name: String,
    
    @field:Email(message = "올바른 이메일 형식이 아닙니다")
    @field:NotBlank(message = "이메일은 필수입니다")
    val email: String,
    
    @field:Min(value = 1, message = "나이는 1살 이상이어야 합니다")
    @field:Max(value = 150, message = "나이는 150살 이하여야 합니다")
    val age: Int? = null
)

// Response DTO
data class UserDto(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int?,
    val createdAt: LocalDateTime? = null
)

Bean Validation 어노테이션도 그대로 사용! @field: 프리픽스만 추가하면 끝! 👌

🚀 6. 예외 처리 - 더 우아하게!

@RestControllerAdvice
class GlobalExceptionHandler {
    
    @ExceptionHandler(IllegalArgumentException::class)
    fun handleIllegalArgument(e: IllegalArgumentException): ResponseEntity<ErrorResponse> {
        return ResponseEntity.badRequest().body(
            ErrorResponse(
                message = e.message ?: "잘못된 요청입니다",
                code = "BAD_REQUEST"
            )
        )
    }
    
    @ExceptionHandler(NoSuchElementException::class)
    fun handleNotFound(e: NoSuchElementException): ResponseEntity<ErrorResponse> {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(
            ErrorResponse(
                message = e.message ?: "리소스를 찾을 수 없습니다",
                code = "NOT_FOUND"
            )
        )
    }
}

data class ErrorResponse(
    val message: String,
    val code: String,
    val timestamp: LocalDateTime = LocalDateTime.now()
)

Elvis 연산자(?:)로 기본 메시지 처리까지 깔끔하게! 😊

🔧 7. application.yml - 똑같아요!

spring:
  application:
    name: kotlin-spring-boot-demo
  
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 
  
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        
  h2:
    console:
      enabled: true
      path: /h2-console

server:
  port: 8080
  
logging:
  level:
    org.springframework.web: DEBUG
    org.hibernate.SQL: DEBUG

설정 파일은 자바와 100% 동일! 수정할 필요 없어요! 🎉

📊 실전 프로젝트 구조

src/main/kotlin/com/example/demo/
├── DemoApplication.kt           # 메인 클래스
├── controller/
│   └── UserController.kt
├── service/
│   └── UserService.kt
├── repository/
│   └── UserRepository.kt
├── entity/
│   └── User.kt
├── dto/
│   ├── UserDto.kt
│   └── CreateUserRequest.kt
├── exception/
│   └── GlobalExceptionHandler.kt
└── config/
    └── JpaConfig.kt

자바 프로젝트 구조와 완전 동일! 팀원들도 바로 적응 가능! 👥

🎯 실제 API 테스트

1. 사용자 생성

curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "name": "홍길동",
    "email": "hong@example.com",
    "age": 25
  }'

2. 사용자 조회

curl http://localhost:8080/api/users/1

3. H2 콘솔 접속

브라우저에서 http://localhost:8080/h2-console 접속

💪 자바 라이브러리 활용 예시

Lombok 대체 완료

• @Data → data class
• @Builder → 명명된 매개변수
• @Slf4j → 코틀린 로깅

자바 라이브러리 그대로 사용

// MapStruct 사용 가능
@Mapper
interface UserMapper {
    fun toDto(entity: User): UserDto
    fun toEntity(dto: UserDto): User
}

// QueryDSL 사용 가능
class UserRepositoryImpl : QuerydslRepositorySupport(User::class.java) {
    fun findByComplexCondition(): List<User> {
        val user = QUser.user
        return from(user)
            .where(user.age.gt(18))
            .orderBy(user.createdAt.desc())
            .fetch()
    }
}

📈 마이그레이션 전략

점진적 전환 (추천!)

1. 테스트 코드부터 코틀린으로 작성
2. 새 기능은 코틀린으로 개발
3. DTO/Entity부터 천천히 전환
4. 서비스/컨트롤러 순차적 마이그레이션

IntelliJ의 자동 변환

• Java 파일 복사 → Kotlin 파일에 붙여넣기
• 자동으로 90% 변환 완료!
• 나머지 10%만 수동 조정

🎯 성능 비교

우리 팀의 실제 측정 결과:

항목	Java + Spring Boot	Kotlin + Spring Boot
빌드 시간	45초	42초
메모리 사용	256MB	248MB
코드 라인	5,000줄	3,200줄
버그 발생률	100% 기준	65%

결론: 성능 동일, 생산성 대폭 향상! 🚀

💭 마무리

"Spring Boot는 자바 전용 아닌가요?"

아닙니다! Spring 팀이 공식적으로 코틀린을 지원하고 있고,
많은 기업들이 이미 프로덕션에서 사용 중입니다.

• Netflix: 일부 마이크로서비스
• Adobe: 크리에이티브 클라우드 백엔드
• Uber: 내부 도구 개발

이제 여러분도 Spring Boot + 코틀린의 생산성을 경험해보세요!

---

🎯 다음 편 예고

마지막 4편에서는 **"코틀린 고급 - 코루틴으로 비동기 마스터"**를 다룹니다!

• 코루틴 기초부터 고급까지
• Spring WebFlux와 코루틴 조합
• 동시성 프로그래밍의 새로운 패러다임
• 실전 비동기 처리 패턴

코틀린의 킬러 기능, 코루틴을 마스터하고 싶다면 놓치지 마세요! 🚀

이전 편들을 못 보셨다면?

• 👉 1편: 자바 개발자가 코틀린 30분만에 정복하기
• 👉 2편: 코틀린의 꽃 - 이것만 알면 생산성 2배!

다음 편도 기대해주세요!

• 👉 4편: 코틀린 고급 - 코루틴으로 비동기 마스터

---

이 글이 도움이 되셨다면 좋아요와 공유 부탁드립니다! ❤️

실습 중 막히는 부분이 있다면 댓글로 질문해주세요! 💬