MSA에 대한 고찰 (4)

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

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

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(21)
	}
}

repositories {
	mavenCentral()
}

dependencies {
	// 1. Spring MVC + 내장 Tomcat  (구 spring-boot-starter-web)
	implementation("org.springframework.boot:spring-boot-starter-webmvc")
	// 2. JSON 처리 (Jackson 3)
	implementation("org.springframework.boot:spring-boot-starter-jackson")
	// 3. JPA
	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
	// 4. 코틀린 data class 직렬화/역직렬화 — groupId 주의!
	implementation("tools.jackson.module:jackson-module-kotlin")
	// 5. 리플렉션 (stdlib은 Kotlin 플러그인이 자동 추가하므로 생략)
	implementation("org.jetbrains.kotlin:kotlin-reflect")

	// 테스트 (Boot 4는 기술별 test starter 사용, starter-test는 전이 포함됨)
	testImplementation("org.springframework.boot:spring-boot-starter-webmvc-test")
	testImplementation("org.springframework.boot:spring-boot-starter-data-jpa-test")

}

kotlin {
	compilerOptions {
		freeCompilerArgs.addAll("-Xjsr305=strict", "-Xannotation-default-target=param-property")
	}
}

allOpen {
	annotation("jakarta.persistence.Entity")
	annotation("jakarta.persistence.MappedSuperclass")
	annotation("jakarta.persistence.Embeddable")
}

tasks.withType<Test> {
	useJUnitPlatform()
}

package com.example.ecommerce

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class EcommerceApplication

fun main(args: Array<String>) {
	runApplication<EcommerceApplication>(*args)
}

package com.example.ecommerce.domain.user.dto.request

data class JoinUserRequestDto(
    val email: String,
    val name: String,
    val address: String
)

package com.example.ecommerce.domain.user.dto.response

class UserResponseDto(
    val id: Long,
    val email: String,
    val name: String
)

package com.example.ecommerce.domain.user.service

@Service
@Transactional(readOnly = true)
class UserService {

    @Transactional
    fun join(requst: JoinUserRequestDto): UserResponseDto {
        return UserResponseDto(id = 1L, email = requst.email, requst.name)
    }

    fun getUser(userId: Long): UserResponseDto{
        return UserResponseDto(id = userId, email = "test.gmail.com", name = "Test User")
    }
}

package com.example.ecommerce.domain.user.controller

@RestController
@RequestMapping("/api/v1/members")
class UserController(
    // 1. 생성자 주입(DI)
    private val userService: UserService
) {
    @PostMapping("/join")
    fun join(@RequestBody request: JoinUserRequestDto) : UserResponseDto{
        // 2. 요청 DTO를 Service로 전달
        return userService.join(request)
    }

    @GetMapping("/{userId}")
    fun getUser(@PathVariable userId: Long): UserResponseDto{
        return userService.getUser(userId)
    }
}

package com.example.ecommerce.common

@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
class BaseEntity {

    //엔티티 생성 시 자동으로 날짜 주입
    @CreatedDate
    @Column(updatable = false)
    var createdDate: LocalDateTime? = null
        //외부에서 수정 불가능하도록 protected, private set
        protected set


    //엔티티 수정 시 자동으로 날짜 주입
    @LastModifiedDate
    var updatedDate: LocalDateTime? = null
        protected set

}

package com.example.ecommerce.domain.user.entity

class User (

    // 생성 시점에 필요한 비즈니스 필드
    @Column(nullable = false, unique = true)
    var email: String, //email은 변경 가능성이 있으므로 var

    @Column(nullable = false)
    var name: String, //이름도 개명 등으로 변경 가능성 있음

    @Column(nullable = false)
    var address: String,
) : BaseEntity(){
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null
}

package com.example.ecommerce.domain.user.repository

interface UserRepository : JpaRepository<User, Long> {

    //Spring Data JPA 쿼리 메서드
    fun findByEmail(email: String): User?
}

package com.example.ecommerce.domain.user.dto.request

data class JoinUserRequestDto(
    val email: String,
    val name: String,
    val address: String
)

fun JoinUserRequestDto.toEntity(): User {
    return User(
        email = this.email,
        name = this.name,
        address = this.address
    )
}

package com.example.ecommerce.domain.user.dto.response

class UserResponseDto(
    val id: Long,
    val email: String,
    val name: String
)

fun User.toResponseDto(): UserResponseDto {
    return UserResponseDto(
        id = requireNotNull(this.id),
        email = this.email,
        name = this.name
    )
}

package com.example.ecommerce.domain.user.service

@Service
@Transactional(readOnly = true)
class UserService(private val userRepository: UserRepository) {

    @Transactional
    fun join(requst: JoinUserRequestDto): UserResponseDto {
        if(userRepository.findByEmail(requst.email) != null) {
            throw IllegalStateException("User already exists")
        }

        val newUser = requst.toEntity()
        val savedUser = userRepository.save(newUser)

        return savedUser.toResponseDto();
    }

    fun getUser(userId: Long): UserResponseDto{
        val user = userRepository.findByIdOrNull(userId)
            ?: throw EntityNotFoundException("User with id $userId not found")
        return user.toResponseDto()
    }
}