Application Layer와 Domain Layer의 구분 및 설계 원칙

Domain Layer Application Layer Infrastructure │ │ │ │ 이벤트 생성 │ │ │ (Aggregate 상태 변경 시) │ │ │ ─────────────────────────>│ │ │ │ 이벤트 발행/전파 │ │ │ (EventPublisher 호출) │ │ │ ─────────────────────────>│ │ │ │ 메시지 브로커 전송

@Service @Transactional class OrderCommandService( private val orderRepository: OrderRepository, // Repository 의존 허용 private val paymentClient: PaymentClient, // 외부 Client 의존 허용 private val eventPublisher: ApplicationEventPublisher // Spring 의존 허용 ) { fun placeOrder(command: PlaceOrderCommand): OrderId { // Application Service는 "흐름"을 조율 val order = Order.create(command.userId, command.items) // Domain 호출 orderRepository.save(order) paymentClient.requestPayment(order.totalAmount) eventPublisher.publishEvent(OrderPlacedEvent(order.id)) return order.id } }

┌──────────────────────────────────────────────────────────┐ │ Presentation Layer │ │ │ │ ┌──────────────────────────────────────────────┐ │ │ │ Controller │ │ │ └────────────────────┬─────────────────────────┘ │ │ │ │ └────────────────────────┼─────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────┐ │ Application Layer │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ │ │ Handler │ │ Listener │ │ Scheduler │ │ │ │ (Message)│ │ (Event) │ │ (Cron) │ │ │ └────┬─────┘ └────┬─────┘ └────────┬─────────┘ │ │ │ │ │ │ │ └──────────────┼──────────────────┘ │ │ ▼ │ │ ┌──────────────────────────────────────────────┐ │ │ │ Application Service │ │ │ │ (UseCase 구현, 트랜잭션 관리) │ │ │ └──────────────────────────────────────────────┘ │ │ │ │ └──────────────────────────┼───────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────┐ │ Domain Layer │ │ │ │ ┌────────┐ ┌────────────┐ ┌────────────────┐ │ │ │ Entity │ │ Value │ │ Domain │ │ │ │ │ │ Object │ │ Service │ │ │ └────────┘ └────────────┘ └────────────────┘ │ │ │ └──────────────────────────────────────────────────────────┘

// Handler는 "트리거" 역할, Service는 "UseCase 실행" 역할 @Component class OrderEventHandler( private val orderService: OrderCommandService ) { @EventListener fun handle(event: PaymentCompletedEvent) { orderService.confirmOrder(event.orderId) } }

// 좋은 예: 순수한 조율만 담당 @Service class OrderFacade( private val orderService: OrderCommandService, private val inventoryService: InventoryService, private val notificationService: NotificationService ) { fun processOrder(command: ProcessOrderCommand) { orderService.createOrder(command) inventoryService.decreaseStock(command.items) notificationService.sendConfirmation(command.userId) } } // 나쁜 예: 도메인 규칙이 Facade로 유출 @Service class OrderFacade(...) { fun processOrder(command: ProcessOrderCommand) { // 이런 판단은 Domain Layer에 있어야 함 if (command.totalAmount > 100_000 && user.isVip()) { orderService.createPriorityOrder(command) } else { orderService.createOrder(command) } } }

// 불변식: "주문 수량은 1 이상이어야 한다" class OrderItem private constructor( val productId: ProductId, val quantity: Int ) { init { require(quantity >= 1) { "주문 수량은 1 이상이어야 합니다" } } companion object { fun create(productId: ProductId, quantity: Int): OrderItem { return OrderItem(productId, quantity) } } }

class Order private constructor( val id: OrderId, private val _items: MutableList<OrderItem>, private var _status: OrderStatus ) { val items: List<OrderItem> get() = _items.toList() val status: OrderStatus get() = _status // 상태 변경은 Aggregate Root를 통해서만 fun addItem(item: OrderItem) { check(_status == OrderStatus.DRAFT) { "확정된 주문에는 상품을 추가할 수 없습니다" } _items.add(item) } fun confirm() { check(_items.isNotEmpty()) { "상품이 없는 주문은 확정할 수 없습니다" } _status = OrderStatus.CONFIRMED } }

// Anemic Domain Model (빈약한 도메인 모델) data class Order( val id: OrderId, var items: MutableList<OrderItem>, // 외부에서 직접 조작 가능 var status: OrderStatus // 외부에서 직접 변경 가능 ) // Service에서 비즈니스 규칙 처리 - 로직이 분산됨 class OrderService { fun addItem(order: Order, item: OrderItem) { if (order.status != OrderStatus.DRAFT) { throw IllegalStateException("확정된 주문에는 상품을 추가할 수 없습니다") } order.items.add(item) } } // Rich Domain Model (풍부한 도메인 모델) class Order private constructor(...) { // 비즈니스 규칙이 Entity 내부에 캡슐화됨 fun addItem(item: OrderItem) { check(_status == OrderStatus.DRAFT) { "확정된 주문에는 상품을 추가할 수 없습니다" } _items.add(item) } }

// Aggregate: 상태를 가지며, 자신의 불변식을 보호 class Order private constructor( val id: OrderId, private var _status: OrderStatus, private val _items: MutableList<OrderItem> ) { fun addItem(item: OrderItem) { check(_status == OrderStatus.DRAFT) { "확정된 주문에는 상품을 추가할 수 없습니다" } _items.add(item) } } // Domain Service: 상태 없이 순수 계산/판단만 수행 // - 여러 Aggregate에 걸친 규칙 // - 단일 Entity에 넣기 어색한 비즈니스 정책 class PricingPolicy { fun calculateDiscount(userGrade: UserGrade, orderAmount: Money): Money { val rate = when (userGrade) { UserGrade.VIP -> Percentage(15) UserGrade.GOLD -> Percentage(10) else -> Percentage(0) } return orderAmount * rate } } // Application Service: 외부 의존성과 트랜잭션 관리 @Service @Transactional class OrderCommandService( private val orderRepository: OrderRepository, private val userRepository: UserRepository, private val pricingPolicy: PricingPolicy ) { fun placeOrder(command: PlaceOrderCommand): OrderId { val user = userRepository.findById(command.userId) val order = Order.create(command.userId, command.items) val discount = pricingPolicy.calculateDiscount(user.grade, order.totalAmount) order.applyDiscount(discount) orderRepository.save(order) return order.id } }

// 잘못된 Domain Service: interface 의존 있음 class PricingDomainService( private val discountRepository: DiscountRepository // ❌ interface라도 외부 의존성 ) { fun calculatePrice(order: Order): Money { val discount = discountRepository.findByUserId(order.userId) // ❌ mock 필요 return order.totalAmount - discount.amount } } // 올바른 Domain Service: 순수 함수/계산만 class PricingPolicy { fun calculateDiscountedPrice(totalAmount: Money, discount: Discount): Money { return totalAmount - discount.amount } fun determineDiscountRate(userGrade: UserGrade, orderCount: Int): Percentage { return when { userGrade == UserGrade.VIP && orderCount >= 100 -> Percentage(20) userGrade == UserGrade.VIP -> Percentage(15) orderCount >= 50 -> Percentage(10) else -> Percentage(0) } } }

class PricingPolicyTest { private val policy = PricingPolicy() // ✅ Spring 없이, mock 없이 순수 인스턴스화 @Test fun `VIP이고 100회 이상 주문시 20% 할인`() { val rate = policy.determineDiscountRate(UserGrade.VIP, 100) assertThat(rate).isEqualTo(Percentage(20)) } }

┌──────────────────────────────────────────────────────────┐ │ Domain Layer │ │ │ │ ┌────────────────────────────────────────────────┐ │ │ │ OrderRepository (interface = Port) │ │ │ └────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────┘ ▲ │ implements (DIP) │ ┌──────────────────────────────────────────────────────────┐ │ Infrastructure Layer │ │ │ │ ┌────────────────────────────────────────────────┐ │ │ │ JpaOrderRepository (구현체 = Adapter) │ │ │ └────────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────────┘

// Repository interface는 Domain에 // domain/repository/OrderRepository.kt interface OrderRepository { fun findById(id: OrderId): Order? fun save(order: Order) } // 이 Repository를 사용하는 Service는 Application에 // application/service/OrderCommandService.kt @Service class OrderCommandService( private val orderRepository: OrderRepository // Application Service에서 사용 ) { ... }

// 1단계: 순수한 Domain Service로 시작 class OrderValidationPolicy { fun validate(order: Order): ValidationResult { return when { order.items.isEmpty() -> ValidationResult.failure("상품이 없습니다") order.totalAmount <= Money.ZERO -> ValidationResult.failure("금액이 올바르지 않습니다") else -> ValidationResult.success() } } } // 2단계: "재사용"을 위해 Repository 추가 (오염 시작) class OrderValidationPolicy( private val userRepository: UserRepository // ❌ 오염! ) { fun validate(order: Order): ValidationResult { val user = userRepository.findById(order.userId) // ❌ DB 의존 // ... } } // 3단계: 더 많은 의존성 추가 (UseCase가 됨) class OrderValidationPolicy( private val userRepository: UserRepository, private val inventoryClient: InventoryClient, // ❌ 외부 API private val eventPublisher: EventPublisher // ❌ 이벤트 발행 ) { // 이제 이것은 Domain Service가 아니라 Application Service }

// "재사용 가능한" Domain Service를 만들려다 생긴 문제 class UniversalOrderPolicy( private val orderRepository: OrderRepository, private val userRepository: UserRepository, private val inventoryRepository: InventoryRepository ) { fun process(order: Order, mode: ProcessMode): ProcessResult { return when (mode) { ProcessMode.VALIDATION -> { // 검증 로직 } ProcessMode.CALCULATION -> { // 계산 로직 } ProcessMode.FULL_PROCESS -> { // 전체 프로세스 (트랜잭션 필요) } } } }

// Facade가 도메인 규칙을 포함 @Service class CheckoutFacade( private val orderService: OrderCommandService, private val paymentService: PaymentService, private val shippingService: ShippingService ) { fun checkout(command: CheckoutCommand): CheckoutResult { val order = orderService.getOrder(command.orderId) // 이런 비즈니스 규칙은 Domain에 있어야 함 val shippingFee = if (order.totalAmount >= Money.of(50_000)) { Money.ZERO // 5만원 이상 무료배송 } else { Money.of(3_000) } // 결제 방식 결정 로직도 Domain의 책임 val paymentMethod = when { order.totalAmount >= Money.of(100_000) -> PaymentMethod.INSTALLMENT command.user.hasDefaultCard() -> PaymentMethod.CARD else -> PaymentMethod.BANK_TRANSFER } // ... } }

// Domain Service로 비즈니스 규칙 이동 class ShippingFeePolicy { fun calculate(orderAmount: Money): Money { return if (orderAmount >= Money.of(50_000)) Money.ZERO else Money.of(3_000) } } class PaymentMethodPolicy { fun determine(orderAmount: Money, user: User): PaymentMethod { return when { orderAmount >= Money.of(100_000) -> PaymentMethod.INSTALLMENT user.hasDefaultCard() -> PaymentMethod.CARD else -> PaymentMethod.BANK_TRANSFER } } } // Facade는 순수한 조율만 @Service class CheckoutFacade( private val orderService: OrderCommandService, private val paymentService: PaymentService, private val shippingFeePolicy: ShippingFeePolicy, private val paymentMethodPolicy: PaymentMethodPolicy ) { fun checkout(command: CheckoutCommand): CheckoutResult { val order = orderService.getOrder(command.orderId) val shippingFee = shippingFeePolicy.calculate(order.totalAmount) val paymentMethod = paymentMethodPolicy.determine(order.totalAmount, command.user) // 조율만 담당 shippingService.setFee(order, shippingFee) paymentService.process(order, paymentMethod) // ... } }