DDD와 헥사고날 아키텍처 실전 가이드

// 문제 예시: 도메인 객체가 JPA에 종속
@Entity
class Order(
    @Id @GeneratedValue
    val id: Long,
    
    @OneToMany(cascade = [CascadeType.ALL])  // JPA 기술이 도메인에 침투
    val items: List<OrderItem>
)

// 📌 Outbound Port (인터페이스) - application 계층에 위치
interface OrderRepository {
    fun save(order: Order): Order
    fun findById(id: OrderId): Order?
}

interface PaymentGateway {
    fun process(payment: Payment): PaymentResult
}

// 📌 Adapter (구현체) - infrastructure 계층에 위치
@Repository
class JpaOrderRepository(
    private val jpaRepository: JpaOrderJpaRepository
) : OrderRepository {
    
    override fun save(order: Order): Order {
        val entity = OrderEntity.from(order)
        return jpaRepository.save(entity).toDomain()
    }
    
    override fun findById(id: OrderId): Order? {
        return jpaRepository.findById(id.value)?.toDomain()
    }
}

@Component
class TossPaymentAdapter(
    private val tossClient: TossPaymentClient
) : PaymentGateway {
    
    override fun process(payment: Payment): PaymentResult {
        val response = tossClient.requestPayment(payment.toRequest())
        return response.toResult()
    }
}

// 📌 Application Service - Port에만 의존
@Service
class OrderService(
    private val orderRepository: OrderRepository,  // Port에 의존
    private val paymentGateway: PaymentGateway     // Port에 의존
) {
    fun placeOrder(command: PlaceOrderCommand): OrderId {
        val order = Order.create(command)
        
        val paymentResult = paymentGateway.process(order.payment)
        order.completePayment(paymentResult)
        
        return orderRepository.save(order).id
    }
}

// ❌ 문제: Port가 JPA에 종속됨
interface OrderRepository : JpaRepository<Order, Long>  // JPA 기술이 도메인에 침투!

// application/port/out/OrderRepository.kt
interface OrderRepository {
    fun save(order: Order): Order
    fun findById(id: OrderId): Order?
    fun findByMemberId(memberId: Long): List<Order>
}
// JPA 의존성 없음!

// infrastructure/persistence/OrderEntity.kt
@Entity
@Table(name = "orders")
class OrderEntity(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,
    
    @Column(name = "member_id")
    val memberId: Long,
    
    @Enumerated(EnumType.STRING)
    val status: String,
    
    @OneToMany(cascade = [CascadeType.ALL], orphanRemoval = true)
    val items: MutableList<OrderItemEntity> = mutableListOf()
) {
    // Entity → Domain 변환
    fun toDomain(): Order = Order(
        id = OrderId(id),
        memberId = memberId,
        status = OrderStatus.valueOf(status),
        items = items.map { it.toDomain() }.toMutableList()
    )
    
    companion object {
        // Domain → Entity 변환
        fun from(order: Order) = OrderEntity(
            id = order.id.value,
            memberId = order.memberId,
            status = order.status.name,
            items = order.items.map { OrderItemEntity.from(it) }.toMutableList()
        )
    }
}

// infrastructure/persistence/OrderJpaRepository.kt
interface OrderJpaRepository : JpaRepository<OrderEntity, Long> {
    fun findByMemberId(memberId: Long): List<OrderEntity>
}
// 외부에 노출되지 않음

// infrastructure/persistence/OrderRepositoryAdapter.kt
@Repository
class OrderRepositoryAdapter(
    private val jpaRepository: OrderJpaRepository
) : OrderRepository {
    
    override fun save(order: Order): Order {
        val entity = OrderEntity.from(order)
        return jpaRepository.save(entity).toDomain()
    }
    
    override fun findById(id: OrderId): Order? {
        return jpaRepository.findById(id.value)
            .map { it.toDomain() }
            .orElse(null)
    }
    
    override fun findByMemberId(memberId: Long): List<Order> {
        return jpaRepository.findByMemberId(memberId)
            .map { it.toDomain() }
    }
}

class Order(
    val id: OrderId,                    // 식별자
    private var status: OrderStatus,
    private val items: MutableList<OrderItem>
) {
    fun cancel() {
        require(status.isCancellable) { "취소할 수 없는 상태입니다" }
        status = OrderStatus.CANCELLED
    }
}

// ✅ Value Object - 불변, equals는 값으로 비교
data class Money(
    val amount: BigDecimal,
    val currency: Currency
) {
    init {
        require(amount >= BigDecimal.ZERO) { "금액은 0 이상이어야 합니다" }
    }
    
    operator fun plus(other: Money): Money {
        require(currency == other.currency) { "통화가 일치해야 합니다" }
        return Money(amount + other.amount, currency)
    }
}

data class Address(
    val city: String,
    val street: String,
    val zipCode: String
)

// Order가 Aggregate Root
class Order(
    val id: OrderId,
    private val orderer: Orderer,                     // Value Object
    private val items: MutableList<OrderItem>,        // Entity (하위)
    private var shippingAddress: Address              // Value Object
) {
    // 외부에서는 반드시 Aggregate Root를 통해서만 접근
    fun addItem(product: ProductSnapshot, quantity: Int) {
        val item = OrderItem(
            productId = product.id,
            productName = product.name,
            price = product.price,
            quantity = quantity
        )
        items.add(item)
    }
    
    fun changeShippingAddress(newAddress: Address) {
        require(status.isAddressChangeable) { "배송지 변경이 불가능한 상태입니다" }
        shippingAddress = newAddress
    }
}

// 할인 계산은 여러 Aggregate에 걸친 로직
@Service
class DiscountCalculator {
    fun calculate(
        order: Order,
        memberGrade: MemberGrade,
        availableCoupons: List<Coupon>
    ): DiscountResult {
        val gradeDiscount = memberGrade.discountRate * order.totalAmount
        val couponDiscount = findBestCoupon(availableCoupons, order)
        return DiscountResult(gradeDiscount + couponDiscount)
    }
}

// Aggregate Root만 Repository를 가짐
interface OrderRepository {
    fun save(order: Order): Order
    fun findById(id: OrderId): Order?
    fun findByOrdererId(ordererId: MemberId): List<Order>
}

// ❌ 잘못된 예: 하위 엔티티에 대한 Repository
interface OrderItemRepository  // Aggregate 경계 위반!

// 이벤트 정의
data class OrderPlacedEvent(
    val orderId: OrderId,
    val ordererId: MemberId,
    val totalAmount: Money,
    val occurredAt: Instant = Instant.now()
)

// Aggregate에서 이벤트 발행
class Order(...) : AbstractAggregateRoot<Order>() {
    
    fun place(): Order {
        // 비즈니스 로직...
        status = OrderStatus.PLACED
        
        // 도메인 이벤트 등록
        registerEvent(OrderPlacedEvent(id, orderer.memberId, totalAmount))
        
        return this
    }
}

class Order(
    private val items: MutableList<OrderItem>
) {
    // 불변식: 주문 금액은 최소 10,000원 이상이어야 한다
    fun addItem(item: OrderItem) {
        items.add(item)
        require(totalAmount >= Money.of(10_000)) {
            "주문 금액은 최소 10,000원 이상이어야 합니다"
        }
    }
}

// ❌ 너무 큰 Aggregate
class Order(
    val items: List<OrderItem>,
    val payments: List<Payment>,      // 별도 Aggregate로 분리
    val shipments: List<Shipment>,    // 별도 Aggregate로 분리
    val reviews: List<Review>         // 별도 Aggregate로 분리
)

// ✅ 적절한 크기
class Order(val items: List<OrderItem>)
class Payment(val orderId: OrderId)    // ID로만 참조
class Shipment(val orderId: OrderId)   // ID로만 참조

// ❌ 잘못된 방식 - 객체 직접 참조
class Order(
    val customer: Customer  // 다른 Aggregate를 직접 참조
)

// ✅ 올바른 방식 - ID로 참조
class Order(
    val customerId: CustomerId  // ID로만 참조
)

// Order Aggregate
class Order(...) {
    fun place() {
        status = OrderStatus.PLACED
        registerEvent(OrderPlacedEvent(id, totalAmount))
    }
}

// 이벤트 핸들러에서 다른 Aggregate 처리
@EventListener
class InventoryEventHandler(
    private val inventoryService: InventoryService
) {
    @Async
    fun handle(event: OrderPlacedEvent) {
        // 재고 차감은 별도 트랜잭션
        inventoryService.decreaseStock(event.orderId)
    }
}

// 주문 Context
data class Orderer(
    val memberId: Long,     // 원본 참조용 ID
    val name: String,       // 주문 시점의 스냅샷
    val phone: String       // 주문 시점의 스냅샷
)

// 주문 생성 시
class OrderService(
    private val memberQueryPort: MemberQueryPort  // 회원 Context 조회 Port
) {
    fun createOrder(memberId: Long, ...): Order {
        val member = memberQueryPort.findById(memberId)
        
        // 스냅샷 생성 - 이후 원본이 바뀌어도 주문의 주문자 정보는 유지
        val orderer = Orderer(
            memberId = member.id,
            name = member.name,
            phone = member.phone
        )
        
        return Order(orderer = orderer, ...)
    }
}

// 공유 모듈
package shared.model

data class Money(val amount: BigDecimal, val currency: Currency)
data class Address(val city: String, val street: String, val zipCode: String)

// 외부 레거시 시스템의 모델
data class LegacyCustomerDto(
    val custNo: String,
    val custNm: String,
    val telNo: String
)

// ACL - 번역 레이어
@Component
class CustomerTranslator {
    fun translate(legacy: LegacyCustomerDto): Orderer {
        return Orderer(
            memberId = legacy.custNo.toLong(),
            name = legacy.custNm,
            phone = formatPhone(legacy.telNo)
        )
    }
}

// 주문 Context에서 발행
@Service
class OrderService {
    fun placeOrder(command: PlaceOrderCommand) {
        val order = Order.create(command)
        orderRepository.save(order)
        
        // 이벤트 발행 - 재고, 결제, 알림 Context가 구독
        eventPublisher.publish(OrderPlacedEvent(order.id, order.items))
    }
}

// 재고 Context에서 구독
@Service
class InventoryEventHandler {
    @EventListener
    fun on(event: OrderPlacedEvent) {
        event.items.forEach { item ->
            inventoryService.decrease(item.productId, item.quantity)
        }
    }
}

// ✅ 올바른 의존성 방향
// infrastructure → application → domain

// domain: 외부 의존성 없음
package com.example.order.domain.model

class Order(...)  // 순수 Kotlin, 프레임워크 의존성 없음

// application: domain에만 의존
package com.example.order.application.service

import com.example.order.domain.model.Order
import com.example.order.application.port.out.OrderRepository

@Service
class OrderService(
    private val orderRepository: OrderRepository  // Port (인터페이스)
)

// infrastructure: application과 domain에 의존
package com.example.order.infrastructure.persistence

import com.example.order.application.port.out.OrderRepository
import com.example.order.domain.model.Order

@Repository
class JpaOrderRepository : OrderRepository {  // Adapter (구현체)
    // JPA, Spring 의존성은 여기에만
}