클린 아키텍처 (Clean Architecture)#

// ❌ 규칙 위반: Entity가 Framework를 알고 있음
public class Order {
    @Entity  // JPA 어노테이션 = Framework!
    @Table(name = "orders")
    public void save() {
        // Spring의 뭔가를 사용...
    }
}

// ✅ 규칙 준수: Entity는 순수한 비즈니스 로직만
public class Order {
    private OrderId id;
    private Money totalAmount;

    public void confirm() {
        // 순수한 비즈니스 로직만
        if (!canBeConfirmed()) {
            throw new IllegalStateException("확정할 수 없습니다");
        }
        this.status = OrderStatus.CONFIRMED;
    }
}

// Entities Layer
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderLine> lines;
    private OrderStatus status;
    private Money totalAmount;

    // 핵심 비즈니스 규칙
    public void confirm() {
        validateCanConfirm();
        this.status = OrderStatus.CONFIRMED;
    }

    public void cancel() {
        validateCanCancel();
        this.status = OrderStatus.CANCELLED;
    }

    public boolean isVipOrder() {
        return totalAmount.isGreaterThan(Money.of(1_000_000));
    }

    private void validateCanConfirm() {
        if (status != OrderStatus.PENDING) {
            throw new InvalidOrderStateException("PENDING 상태에서만 확정 가능");
        }
        if (lines.isEmpty()) {
            throw new EmptyOrderException("주문 항목이 없습니다");
        }
    }
}

// Value Object (Entities Layer에 포함)
public record Money(BigDecimal amount, Currency currency) {

    public Money {
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("금액은 0 이상이어야 합니다");
        }
    }

    public boolean isGreaterThan(Money other) {
        return this.amount.compareTo(other.amount) > 0;
    }

    public Money add(Money other) {
        validateSameCurrency(other);
        return new Money(this.amount.add(other.amount), this.currency);
    }
}

// Use Case Interface (Input Port)
public interface CreateOrderUseCase {
    CreateOrderOutput execute(CreateOrderInput input);
}

// Input (Request Model)
public record CreateOrderInput(
    String customerId,
    List<OrderLineInput> lines
) {}

// Output (Response Model)
public record CreateOrderOutput(
    String orderId,
    String status,
    BigDecimal totalAmount
) {}

// Use Case 구현 (Interactor)
public class CreateOrderInteractor implements CreateOrderUseCase {

    // Output Ports (외부와의 연결은 인터페이스로)
    private final OrderRepository orderRepository;
    private final InventoryGateway inventoryGateway;
    private final PaymentGateway paymentGateway;

    @Override
    public CreateOrderOutput execute(CreateOrderInput input) {
        // 1. 재고 확인
        for (OrderLineInput line : input.lines()) {
            if (!inventoryGateway.checkAvailability(line.productId(), line.quantity())) {
                throw new InsufficientInventoryException(line.productId());
            }
        }

        // 2. Entity 생성 (핵심 비즈니스 로직은 Entity에)
        Order order = Order.create(
            CustomerId.of(input.customerId()),
            toOrderLines(input.lines())
        );

        // 3. 저장
        orderRepository.save(order);

        // 4. Output 생성
        return new CreateOrderOutput(
            order.getId().getValue(),
            order.getStatus().name(),
            order.getTotalAmount().getAmount()
        );
    }
}

// Controller (HTTP → Use Case)
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final CreateOrderUseCase createOrderUseCase;

    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @RequestBody CreateOrderRequest request) {

        // 1. HTTP Request → Use Case Input 변환
        CreateOrderInput input = new CreateOrderInput(
            request.customerId(),
            request.items().stream()
                .map(this::toOrderLineInput)
                .toList()
        );

        // 2. Use Case 실행
        CreateOrderOutput output = createOrderUseCase.execute(input);

        // 3. Use Case Output → HTTP Response 변환
        OrderResponse response = new OrderResponse(
            output.orderId(),
            output.status(),
            output.totalAmount()
        );

        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }
}

// Gateway 구현 (Repository)
@Repository
public class JpaOrderRepository implements OrderRepository {

    private final OrderJpaRepository jpaRepository;
    private final OrderDataMapper mapper;

    @Override
    public void save(Order order) {
        // Domain Entity → JPA Entity 변환
        JpaOrderEntity entity = mapper.toJpaEntity(order);
        jpaRepository.save(entity);
    }

    @Override
    public Optional<Order> findById(OrderId id) {
        // JPA Entity → Domain Entity 변환
        return jpaRepository.findById(id.getValue())
            .map(mapper::toDomain);
    }
}

// Framework Layer: Spring 설정
@Configuration
public class OrderConfig {

    @Bean
    public CreateOrderUseCase createOrderUseCase(
            OrderRepository orderRepository,
            InventoryGateway inventoryGateway) {
        return new CreateOrderInteractor(orderRepository, inventoryGateway);
    }
}

// Framework Layer: JPA Entity
@Entity
@Table(name = "orders")
public class JpaOrderEntity {
    @Id
    private String id;
    private String customerId;
    private String status;
    private BigDecimal totalAmount;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<JpaOrderLineEntity> lines;
}

// Framework Layer: Spring Data Repository
public interface OrderJpaRepository extends JpaRepository<JpaOrderEntity, String> {
}

// ❌ 잘못된 예: Entity가 JPA에 의존
@Entity  // JPA 어노테이션!
public class Order {
    @Id
    @GeneratedValue
    private Long id;

    @Transactional  // Spring 어노테이션!
    public void confirm() { ... }
}

// ✅ 올바른 예: 순수한 Entity
public class Order {
    private OrderId id;
    private OrderStatus status;

    public void confirm() {
        // 순수한 비즈니스 로직만
    }
}

// ❌ 잘못된 예: Use Case가 HTTP 객체 사용
public class CreateOrderInteractor {
    public ResponseEntity<?> execute(HttpServletRequest request) {
        // Use Case가 HTTP를 알면 안 됨!
    }
}

// ✅ 올바른 예: 순수한 Input/Output
public class CreateOrderInteractor {
    public CreateOrderOutput execute(CreateOrderInput input) {
        // HTTP와 무관한 순수 객체
    }
}

// ❌ 잘못된 예: Interactor가 Presenter 의존
public class CreateOrderInteractor {
    private final OrderPresenter presenter;  // Adapter에 의존!

    public void execute(CreateOrderInput input) {
        Order order = ...;
        presenter.present(order);  // 안 됨!
    }
}

// ✅ 올바른 예: Output 객체 반환
public class CreateOrderInteractor {
    public CreateOrderOutput execute(CreateOrderInput input) {
        Order order = ...;
        return new CreateOrderOutput(order.getId(), ...);  // Output 반환
    }
}

// ❌ 잘못된 예: 구체 클래스 의존
public class CreateOrderInteractor {
    private final JpaOrderRepository repository;  // 구체 클래스!
}

// ✅ 올바른 예: 인터페이스 의존
public class CreateOrderInteractor {
    private final OrderRepository repository;  // 인터페이스!
}

class OrderTest {

    @Test
    void 주문_확정_성공() {
        Order order = Order.create(
            CustomerId.of("c1"),
            List.of(new OrderLine(ProductId.of("p1"), 2, Money.of(10000)))
        );

        order.confirm();

        assertThat(order.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
    }

    @Test
    void VIP_주문_판별() {
        Order order = createOrderWithTotal(Money.of(1_500_000));

        assertThat(order.isVipOrder()).isTrue();
    }
}

@ExtendWith(MockitoExtension.class)
class CreateOrderInteractorTest {

    @Mock private OrderRepository orderRepository;
    @Mock private InventoryGateway inventoryGateway;

    private CreateOrderInteractor interactor;

    @BeforeEach
    void setUp() {
        interactor = new CreateOrderInteractor(orderRepository, inventoryGateway);
    }

    @Test
    void 주문_생성_성공() {
        // Given
        when(inventoryGateway.checkAvailability(any(), anyInt())).thenReturn(true);

        CreateOrderInput input = new CreateOrderInput(
            "customer-1",
            List.of(new OrderLineInput("product-1", 2, 10000))
        );

        // When
        CreateOrderOutput output = interactor.execute(input);

        // Then
        verify(orderRepository).save(any(Order.class));
        assertThat(output.orderId()).isNotNull();
        assertThat(output.status()).isEqualTo("PENDING");
    }

    @Test
    void 재고_부족시_예외() {
        when(inventoryGateway.checkAvailability(any(), anyInt())).thenReturn(false);

        CreateOrderInput input = new CreateOrderInput(
            "customer-1",
            List.of(new OrderLineInput("product-1", 100, 10000))
        );

        assertThrows(InsufficientInventoryException.class,
            () -> interactor.execute(input));
    }
}

@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired private MockMvc mockMvc;
    @MockBean private CreateOrderUseCase createOrderUseCase;

    @Test
    void 주문_생성_API() throws Exception {
        when(createOrderUseCase.execute(any()))
            .thenReturn(new CreateOrderOutput("order-123", "PENDING", BigDecimal.valueOf(20000)));

        mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                    {
                        "customerId": "c1",
                        "items": [{"productId": "p1", "quantity": 2, "price": 10000}]
                    }
                    """))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.orderId").value("order-123"));
    }
}

// Service에서 비즈니스 로직을 Entity로 이동
// Before
public class OrderService {
    public void confirm(Order order) {
        if (order.getStatus().equals("PENDING")) {
            order.setStatus("CONFIRMED");
        }
    }
}

// After
public class Order {
    public void confirm() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException();
        }
        this.status = OrderStatus.CONFIRMED;
    }
}

// Service를 Use Case 인터페이스로 추상화
public interface ConfirmOrderUseCase {
    void execute(OrderId orderId);
}

public class ConfirmOrderInteractor implements ConfirmOrderUseCase {
    // ...
}

// Repository를 Gateway 인터페이스로
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
}