모놀리스를 모듈러/서비스로 나누기

목표가 명확한가?
  ├─ NO → 모놀리스 유지. 목표부터 정해라.
  └─ YES
      └─ 모듈러 모놀리스로 충분한가?
          ├─ YES → 1단계: 모듈화
          └─ NO  → 2단계: 데이터 분리 → 3단계: Strangler 분리

[이벤트 스토밍 워크숍 결과]

주문 Bounded Context:        결제 Bounded Context:
┌──────────────────┐         ┌──────────────────┐
│ OrderCreated     │────────→│ PaymentRequested  │
│ OrderCancelled   │         │ PaymentCompleted  │
│ OrderShipped     │         │ PaymentFailed     │
└──────────────────┘         └──────────────────┘
         │
         ↓
배송 Bounded Context:
┌──────────────────┐
│ ShipmentCreated  │
│ ShipmentDelivered│
└──────────────────┘

// ❌ 분리 불가한 강결합 트랜잭션 (한 TX에 3개 도메인)
@Transactional
public void placeOrder(OrderRequest req) {
    Order order = orderRepository.save(toOrder(req));
    Payment payment = paymentRepository.save(toPayment(order));
    Inventory inventory = inventoryRepository.decrementStock(req.getProductId(), req.getQty());
    // → 세 도메인이 한 트랜잭션에 묶여 있음
}

// ✅ 분리 가능한 설계: 이벤트 기반 느슨한 결합
@Transactional
public void placeOrder(OrderRequest req) {
    Order order = orderRepository.save(toOrder(req));
    // 주문 컨텍스트 내에서만 트랜잭션
    eventPublisher.publish(new OrderCreatedEvent(order.getId(), req.getProductId(), req.getQty()));
}

// 결제 모듈 — 별도 트랜잭션
@EventListener
@Transactional
public void onOrderCreated(OrderCreatedEvent event) {
    paymentService.requestPayment(event.getOrderId());
}

// 재고 모듈 — 별도 트랜잭션
@EventListener
@Transactional
public void onOrderCreated(OrderCreatedEvent event) {
    inventoryService.reserve(event.getProductId(), event.getQty());
}

com.example.shop/
├── order/                    # 주문 모듈
│   ├── api/                  # 외부 노출 (Controller)
│   ├── application/          # UseCase/Service
│   ├── domain/               # Entity, VO, Repository(interface)
│   ├── infrastructure/       # JPA impl, 외부 API client
│   └── OrderModuleApi.java   # 다른 모듈이 호출하는 공개 인터페이스
├── payment/                  # 결제 모듈
│   ├── api/
│   ├── application/
│   ├── domain/
│   ├── infrastructure/
│   └── PaymentModuleApi.java
├── shipping/                 # 배송 모듈
└── shared/                   # 공통 (최소화!)
    ├── event/                # 도메인 이벤트 정의
    └── vo/                   # Money, Address 등 공용 VO

import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.ArchRule;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

public class ModuleBoundaryTest {

    @Test
    void 주문모듈은_결제_infrastructure에_직접_접근하지_않는다() {
        ArchRule rule = noClasses()
            .that().resideInAPackage("..order..")
            .should().accessClassesThat()
            .resideInAPackage("..payment.infrastructure..");

        rule.check(new ClassFileImporter()
            .importPackages("com.example.shop"));
    }

    @Test
    void 모듈간_통신은_ModuleApi를_통해서만_한다() {
        ArchRule rule = noClasses()
            .that().resideInAPackage("..order.application..")
            .should().accessClassesThat()
            .resideInAPackage("..payment.application..");

        rule.check(new ClassFileImporter()
            .importPackages("com.example.shop"));
    }
}

// payment/PaymentModuleApi.java — 결제 모듈의 유일한 공개 인터페이스
public interface PaymentModuleApi {
    PaymentResult requestPayment(PaymentCommand cmd);
    PaymentStatus getStatus(Long paymentId);
    void cancelPayment(Long paymentId);
}

// payment/application/PaymentModuleApiImpl.java
@Service
class PaymentModuleApiImpl implements PaymentModuleApi {
    private final PaymentService paymentService;

    @Override
    public PaymentResult requestPayment(PaymentCommand cmd) {
        return paymentService.process(cmd);
    }

    @Override
    public PaymentStatus getStatus(Long paymentId) {
        return paymentService.findStatus(paymentId);
    }

    @Override
    public void cancelPayment(Long paymentId) {
        paymentService.cancel(paymentId);
    }
}

Phase 1: 스키마 분리 (1~2주)
─────────────────────────────
같은 DB 인스턴스, 스키마를 모듈별로 분리
  - order_schema.orders
  - payment_schema.payments
Cross-schema JOIN은 허용하되 목록으로 관리

    ↓

Phase 2: 읽기 경로 분리 (2~4주)
─────────────────────────────
다른 모듈 데이터가 필요하면 API 호출 or 이벤트 구독
  - 주문 → 결제 상태: PaymentModuleApi.getStatus()
  - 검색 → 상품 데이터: CDC로 Elasticsearch 동기화

    ↓

Phase 3: DB 물리 분리 (4~8주)
─────────────────────────────
모듈별 독립 DB 인스턴스
  - order-db, payment-db, shipping-db
  - Cross-schema JOIN 0건 달성 후 분리

// Choreography Saga — 이벤트 기반 (소규모·단순 흐름)
@Component
public class OrderSaga {

    @EventListener
    public void onOrderCreated(OrderCreatedEvent e) {
        // 결제 요청 이벤트 발행
        eventPublisher.publish(new PaymentRequestedEvent(e.getOrderId(), e.getAmount()));
    }

    @EventListener
    public void onPaymentCompleted(PaymentCompletedEvent e) {
        // 재고 차감 이벤트 발행
        eventPublisher.publish(new InventoryReserveEvent(e.getOrderId()));
    }

    @EventListener
    public void onPaymentFailed(PaymentFailedEvent e) {
        // 보상 트랜잭션: 주문 취소
        orderService.cancelOrder(e.getOrderId());
    }

    @EventListener
    public void onInventoryFailed(InventoryReserveFailedEvent e) {
        // 보상 트랜잭션: 결제 취소 → 주문 취소
        paymentService.refund(e.getOrderId());
        orderService.cancelOrder(e.getOrderId());
    }
}

// Orchestration Saga — 중앙 조정자 (복잡한 흐름)
@Service
public class OrderOrchestrator {

    public OrderResult placeOrder(OrderCommand cmd) {
        // 1. 주문 생성
        Order order = orderService.create(cmd);

        // 2. 결제 시도
        PaymentResult payment = paymentClient.requestPayment(order);
        if (payment.isFailed()) {
            orderService.cancel(order.getId());
            return OrderResult.failed("결제 실패");
        }

        // 3. 재고 차감 시도
        InventoryResult inventory = inventoryClient.reserve(order);
        if (inventory.isFailed()) {
            paymentClient.refund(order.getId());   // 보상
            orderService.cancel(order.getId());     // 보상
            return OrderResult.failed("재고 부족");
        }

        // 4. 성공
        orderService.confirm(order.getId());
        return OrderResult.success(order);
    }
}

┌─────────────────────────────────────────┐
│              API Gateway                │
│  (Spring Cloud Gateway / Nginx)         │
│                                         │
│  /api/orders/** ───┐                    │
│  /api/payments/** ─┼──→ 라우팅 결정     │
│  /api/shipping/** ─┘                    │
└───────────┬──────────────┬──────────────┘
            │              │
            ▼              ▼
     ┌──────────┐   ┌──────────┐
     │ 모놀리스  │   │ 새 서비스 │
     │ (Legacy) │   │ (결제)   │
     └──────────┘   └──────────┘

spring:
  cloud:
    gateway:
      routes:
        # Phase 1: Shadow (미러링) — 결과 비교만, 응답은 모놀리스
        - id: payment-shadow
          uri: http://payment-service:8080
          predicates:
            - Path=/api/payments/**
            - Header=X-Shadow, true
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

        # Phase 2: Canary — 10% 트래픽만 새 서비스
        - id: payment-canary
          uri: http://payment-service:8080
          predicates:
            - Path=/api/payments/**
            - Weight=payment-group, 10
          metadata:
            response-timeout: 3000

        # Phase 3: Cutover — 100% 새 서비스
        - id: payment-new
          uri: http://payment-service:8080
          predicates:
            - Path=/api/payments/**

@Component
public class ShadowVerifier {

    private final MeterRegistry meterRegistry;
    private final Counter matchCounter;
    private final Counter mismatchCounter;

    public ShadowVerifier(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.matchCounter = Counter.builder("shadow.result")
            .tag("outcome", "match").register(meterRegistry);
        this.mismatchCounter = Counter.builder("shadow.result")
            .tag("outcome", "mismatch").register(meterRegistry);
    }

    public void verify(String endpoint, Object legacyResponse, Object newResponse) {
        if (Objects.equals(legacyResponse, newResponse)) {
            matchCounter.increment();
        } else {
            mismatchCounter.increment();
            log.warn("[Shadow Mismatch] endpoint={}, legacy={}, new={}",
                endpoint,
                truncate(legacyResponse),
                truncate(newResponse));
        }
    }
}

# Prometheus alerting rule
groups:
  - name: strangler-canary
    rules:
      - alert: CanaryErrorRateHigh
        expr: |
          rate(http_server_requests_seconds_count{service="payment-new", status=~"5.."}[5m])
          / rate(http_server_requests_seconds_count{service="payment-new"}[5m])
          > 0.02
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Canary 에러율 2% 초과 — 자동 롤백 트리거"

// 새 결제 서비스에서 레거시 주문 데이터를 받을 때
@Component
public class LegacyOrderAntiCorruptionLayer {

    private final LegacyOrderClient legacyClient;

    /**
     * 레거시 주문 모델 → 새 결제 컨텍스트의 PaymentOrder로 변환
     * 레거시의 nullable 필드, 다른 이름, 다른 단위를 여기서 정리
     */
    public PaymentOrder toPaymentOrder(Long orderId) {
        LegacyOrderDto legacy = legacyClient.getOrder(orderId);

        return PaymentOrder.builder()
            .orderId(legacy.getId())
            .amount(Money.won(legacy.getTotalPrice()))  // 레거시: int → Money VO
            .customerEmail(Objects.requireNonNullElse(
                legacy.getEmail(), "unknown@example.com"))
            .currency("KRW")  // 레거시에는 통화 필드 없음 — 기본값
            .build();
    }
}

// 소비자(주문 서비스)가 결제 API에 기대하는 계약
@Pact(consumer = "order-service", provider = "payment-service")
public RequestResponsePact createPaymentPact(PactDslWithProvider builder) {
    return builder
        .given("결제 가능한 주문이 존재")
        .uponReceiving("결제 요청")
            .method("POST")
            .path("/api/payments")
            .body(new PactDslJsonBody()
                .integerType("orderId", 1001)
                .decimalType("amount", 50000.0))
        .willRespondWith()
            .status(200)
            .body(new PactDslJsonBody()
                .stringType("paymentId")
                .stringValue("status", "COMPLETED"))
        .toPact();
}