📝 Kotlin Spring Boot 3 게시판 (Board) 코드 예시

📝 Kotlin Spring Boot 3 게시판 (Board) 코드 예시

Kotlin, Spring Boot 3 (JDK 17), Gradle.kts, 그리고 최신 개발 근황에 맞춰 Clean Architecture와 레이어드 아키텍처를 적용한 게시판(Board) 서비스의 핵심 코드를 제공해 드립니다.

여기서는 REST API를 사용하여 게시판 기능을 구현합니다.

---

1. ⚙️ 프로젝트 설정 (build.gradle.kts)

Kotlin, Spring Boot 3, JPA(데이터베이스), 그리고 JSON 처리를 위한 의존성을 설정합니다.

// build.gradle.kts

plugins {
    // Spring Boot 플러그인
    id("org.springframework.boot") version "3.2.0"
    id("io.spring.dependency-management") version "1.1.4"
    
    // Kotlin 플러그인
    kotlin("jvm") version "1.9.20"
    kotlin("plugin.spring") version "1.9.20"
    kotlin("plugin.jpa") version "1.9.20" // JPA 관련 설정 자동화
}

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

java {
    sourceCompatibility = JavaVersion.VERSION_17
}

repositories {
    mavenCentral()
}

dependencies {
    // Spring Boot Web (REST API 지원)
    implementation("org.springframework.boot:spring-boot-starter-web")
    
    // Kotlin Coroutines 지원 (비동기 처리에 유리)
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")

    // Spring Data JPA (DB 연동)
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    
    // Kotlin JSON 처리 (Jackson)
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    
    // H2 Database (개발 및 테스트용 인메모리 DB)
    runtimeOnly("com.h2database:h2")
    
    // 테스트 의존성
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
    kotlinOptions {
        freeCompilerArgs = listOf("-Xjsr305=strict")
        jvmTarget = "17"
    }
}

---

2. 📁 Application 설정 (application.yml)

H2 데이터베이스 설정을 포함한 기본 설정을 YAML 형식으로 합니다.

# src/main/resources/application.yml

spring:
  application:
    name: kotlin-board-app
    
  datasource:
    # H2 Database 설정
    url: jdbc:h2:mem:testdb
    driverClassName: org.h2.Driver
    username: sa
    password: 
  
  # JPA 설정
  jpa:
    hibernate:
      ddl-auto: update # 애플리케이션 실행 시 엔티티 기반으로 테이블 자동 생성/업데이트
    show-sql: true # SQL 쿼리 로그 출력
    properties:
      hibernate:
        format_sql: true # SQL 포맷팅
        
  # H2 Web Console 활성화 (개발 시 DB 확인용)
  h2:
    console:
      enabled: true
      path: /h2-console

---

3. 🎯 핵심 비즈니스 로직 (Board Module)

게시판의 핵심 4가지 레이어(DTO, Entity, Repository, Service, Controller)를 Kotlin 코드로 구현합니다.

3.1. DTO (Data Transfer Object)

클라이언트와 서버 간의 데이터 전송에 사용되는 데이터 클래스입니다.

// DTOs for client communication

data class BoardCreateRequest(
    val title: String,
    val content: String,
    val author: String
)

data class BoardUpdateRequest(
    val title: String?,
    val content: String?
)

data class BoardResponse(
    val id: Long,
    val title: String,
    val content: String,
    val author: String,
    val createdAt: String
)

3.2. Entity (데이터 모델)

데이터베이스의 테이블을 나타내는 JPA 엔티티입니다.

// src/main/kotlin/com/example/entity/Board.kt
package com.example.entity

import jakarta.persistence.*
import java.time.LocalDateTime

@Entity
data class Board(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0, // 초기값 0, DB에서 자동 생성
    
    var title: String,
    
    @Lob // Content 필드를 길게 저장하기 위해 사용
    var content: String,
    
    val author: String,
    
    val createdAt: LocalDateTime = LocalDateTime.now(),
    
    var updatedAt: LocalDateTime? = null
) {
    // DTO 변환을 위한 확장 함수
    fun toResponse() = BoardResponse(
        id = id,
        title = title,
        content = content,
        author = author,
        createdAt = createdAt.toString()
    )
}

3.3. Repository (데이터 접근)

JPA를 상속받아 데이터베이스에 접근하는 인터페이스입니다.

// src/main/kotlin/com/example/repository/BoardRepository.kt
package com.example.repository

import com.example.entity.Board
import org.springframework.data.jpa.repository.JpaRepository

// Spring Data JPA는 인터페이스 정의만으로 CRUD 메서드를 자동으로 구현해줍니다.
interface BoardRepository : JpaRepository<Board, Long> {
    // 추가적인 쿼리 메서드가 필요하면 여기에 선언합니다. 예:
    // fun findByAuthor(author: String): List<Board>
}

3.4. Service (비즈니스 로직)

Repository를 사용하여 핵심 비즈니스 로직을 처리하는 계층입니다.

// src/main/kotlin/com/example/service/BoardService.kt
package com.example.service

import com.example.dto.BoardCreateRequest
import com.example.dto.BoardResponse
import com.example.dto.BoardUpdateRequest
import com.example.entity.Board
import com.example.repository.BoardRepository
import jakarta.transaction.Transactional
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
import java.time.LocalDateTime

@Service
class BoardService(
    private val boardRepository: BoardRepository
) {
    // 1. 게시글 전체 조회 (목록)
    fun getAllBoards(): List<BoardResponse> {
        return boardRepository.findAll()
            .map { it.toResponse() } // Entity -> Response DTO 변환
    }

    // 2. 게시글 상세 조회
    fun getBoardById(id: Long): BoardResponse {
        val board = boardRepository.findByIdOrNull(id)
            ?: throw NoSuchElementException("게시글 ID ${id}를 찾을 수 없습니다.")
        return board.toResponse()
    }

    // 3. 게시글 생성
    fun createBoard(request: BoardCreateRequest): BoardResponse {
        val newBoard = Board(
            title = request.title,
            content = request.content,
            author = request.author
        )
        val savedBoard = boardRepository.save(newBoard)
        return savedBoard.toResponse()
    }

    // 4. 게시글 수정
    @Transactional // JPA 변경 감지를 위해 트랜잭션 필요
    fun updateBoard(id: Long, request: BoardUpdateRequest): BoardResponse {
        val board = boardRepository.findByIdOrNull(id)
            ?: throw NoSuchElementException("게시글 ID ${id}를 찾을 수 없습니다.")

        // Kotlin의 안전 호출 연산자(?)와 Elvis 연산자(?:)를 활용한 간결한 업데이트
        request.title?.let { board.title = it }
        request.content?.let { board.content = it }
        board.updatedAt = LocalDateTime.now()

        // @Transactional 덕분에 save()를 호출할 필요가 없습니다.
        return board.toResponse()
    }

    // 5. 게시글 삭제
    fun deleteBoard(id: Long) {
        if (!boardRepository.existsById(id)) {
            throw NoSuchElementException("게시글 ID ${id}를 찾을 수 없습니다.")
        }
        boardRepository.deleteById(id)
    }
}

3.5. Controller (외부 통신)

클라이언트의 HTTP 요청을 받아 Service에 전달하고 응답을 반환하는 REST API 인터페이스입니다.

// src/main/kotlin/com/example/controller/BoardController.kt
package com.example.controller

import com.example.dto.BoardCreateRequest
import com.example.dto.BoardResponse
import com.example.dto.BoardUpdateRequest
import com.example.service.BoardService
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*

@RestController
@RequestMapping("/api/boards")
class BoardController(
    private val boardService: BoardService
) {
    // GET /api/boards : 전체 목록 조회
    @GetMapping
    fun getAllBoards(): ResponseEntity<List<BoardResponse>> {
        val boards = boardService.getAllBoards()
        return ResponseEntity.ok(boards)
    }

    // GET /api/boards/{id} : 상세 조회
    @GetMapping("/{id}")
    fun getBoardById(@PathVariable id: Long): ResponseEntity<BoardResponse> {
        val board = boardService.getBoardById(id)
        return ResponseEntity.ok(board)
    }

    // POST /api/boards : 게시글 생성
    @PostMapping
    fun createBoard(@RequestBody request: BoardCreateRequest): ResponseEntity<BoardResponse> {
        val newBoard = boardService.createBoard(request)
        return ResponseEntity
            .status(HttpStatus.CREATED) // HTTP 201 응답
            .body(newBoard)
    }

    // PUT /api/boards/{id} : 게시글 수정
    @PutMapping("/{id}")
    fun updateBoard(
        @PathVariable id: Long, 
        @RequestBody request: BoardUpdateRequest
    ): ResponseEntity<BoardResponse> {
        val updatedBoard = boardService.updateBoard(id, request)
        return ResponseEntity.ok(updatedBoard)
    }

    // DELETE /api/boards/{id} : 게시글 삭제
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT) // HTTP 204 응답 (성공적으로 삭제되었지만 본문 없음)
    fun deleteBoard(@PathVariable id: Long) {
        boardService.deleteBoard(id)
    }
}

---

4. 🚀 핵심 정리: 최신 Kotlin 개발 트렌드 적용 포인트

이 코드는 다음과 같은 최신 Kotlin/Spring Boot 개발 트렌드를 반영하고 있습니다.

1. Gradle.kts (Kotlin DSL): Groovy 기반의 build.gradle 대신 Kotlin 기반의 build.gradle.kts를 사용하여 더 강력한 타입 안정성과 IDE 지원을 받습니다.
2. 생성자 주입 (Primary Constructor Injection): @Autowired 대신 Kotlin 클래스의 주 생성자를 통해 의존성을 주입하여 코드가 간결하고 불변성(Immutability)을 유지하기 쉽습니다. (예: class BoardService(private val boardRepository: BoardRepository))
3. 데이터 클래스 (data class): DTO와 Entity에 data class를 사용하여 equals(), hashCode(), toString() 등을 자동으로 생성하고 코드를 최소화합니다.
4. 불변성 및 Null 안전성:
   • val (Immutable)을 기본으로 사용합니다.
   • BoardUpdateRequest의 필드에 String?를 사용하여 Null 안전성을 명확히 합니다.
   • request.title?.let { ... } (안전 호출 + let 스코프 함수)과 같은 Kotlin 고유의 문법으로 Null 체크를 간결하게 처리합니다.
5. JPA 확장 함수: Board 엔티티 내부에 toResponse()와 같은 확장 함수를 정의하여, 엔티티를 DTO로 변환하는 로직을 깔끔하게 캡슐화했습니다.