전체 메뉴

테마

Chapter 16

Composite·Strategy와 모듈 경계

Composite와 Strategy 패턴, Orchestrator의 보상 흐름, 모듈 API 경계와 커밋 이후 이벤트를 Spring Boot 테스트로 구현합니다.

난이도
중급 심화
예상 학습
190분
Spring Boot 기준
Spring Boot 4.1.1
JDK 기준
JDK 21
최종 검토

전체 24개 Chapter 중 Chapter 16입니다. 예제 코드는 공개 저장소 spring-boot-curriculum의 examples/ch25-composite-orchestration 폴더에서 확인할 수 있습니다.

Learning goals

오늘 배울 내용

  • Composite로 할인 규칙을 트리처럼 조립하기
  • Orchestrator에서 작업 순서와 실패 보상 설계하기
  • Strategy Bean 목록으로 조건문 없는 정책 선택 구현하기
  • 모듈의 api와 internal 패키지 경계 정의하기
  • 트랜잭션 커밋 이후 이벤트와 순환 의존 방지하기
  1. Composite 정책 조립
  2. Orchestrator 흐름 제어
  3. Strategy 선택
  4. 모듈 계약 분리
  5. 커밋 이후 이벤트
이 Chapter의 진행 흐름

주문 기능은 처음엔 단순합니다. 그러다 “VIP는 10% 할인”, “5만 원 이상이면 3천 원 할인”, “첫 주문이면 2천 원 할인”이 하나씩 붙고, 어떤 할인은 겹쳐서 적용되고 어떤 할인은 둘 중 하나만 적용되어야 한다는 말이 나옵니다. 배송 방법도 일반, 빠른, 매장 수령으로 늘어납니다. 여기에 재고, 결제, 배송이 순서대로 이어지고 중간에 실패하면 앞의 일을 되돌려야 합니다. 이것들이 if 문으로 한 메서드에 쌓이면 어디를 고쳐야 할지 알 수 없게 됩니다.

이 Chapter는 이 문제를 세 가지 도구로 풉니다. Composite로 규칙 하나와 규칙 묶음을 같은 모양으로 다루고, Orchestration으로 여러 서비스를 부르는 흐름과 실패 시 되돌리기를 한 클래스에 모으고, 전략 패턴으로 if/else 분기를 구현체 추가로 바꿉니다. 마지막으로 코드를 모듈로 나누어 모듈 사이를 정해진 입구(api)와 이벤트로만 오가게 하고, 그 경계를 테스트로 고정합니다. Chapter 12에서 시작한 계약 개념이 여섯 가지 모양으로 이어지는 Chapter이기도 합니다.

이 Chapter에서 만드는 것

만드는 것 설명
DiscountRule, CompositeDiscountRule 합산(sumOf)과 최대값 선택(bestOf)으로 정책 트리 조립
OrderOrchestrator 재고 → 결제 → 배송 순서와 보상(환불, 재고 반환)
ShippingFeeStrategy 배송 방법별 전략 Bean, 계산기는 if/else 없음
모듈 member/catalog/order/reward 각각 api와 internal 패키지
OrderPlaced 이벤트 커밋 이후에만 적립 모듈에 전달
ArchUnit 규칙 순환 없음, internal 비공개, 허용된 의존만
테스트 ch25: 15건, ch34: 12건, ch26: 17건

전체 흐름

  1. Composite로 할인 정책을 조립하고, Orchestrator로 주문 흐름과 보상을 만든 뒤 보상 순서를 테스트합니다(ch25).
  2. 배송비 계산을 전략 패턴으로 바꾸고, 세 도구를 언제 쓰는지 비교합니다(ch34).
  3. 코드를 모듈로 나누고 순환을 막은 뒤, 커밋 이후 이벤트로 모듈 사이를 잇습니다(ch26).
  4. 마지막으로 이 Chapter까지 나온 계약을 한 표로 정리합니다.

직접 실행해 확인한 결과

확인 결과
ch25 test 15건 통과
ch34 test 12건 통과
ch26 test 17건 통과
ch34 실행: standard 49,999원 / 50,000원, express 5kg, 방법 목록, 없는 방법 3000 / 0 / 6500 / ["express","pickup","standard"] / 400
ch26 실행: 정상 주문 / 없는 회원 201 payable 30000 / 404

사전 지식과 준비물

  • Chapter 15의 Port와 의존 방향, Chapter 09의 트랜잭션, Chapter 03의 List 주입.
  • 코드는 examples/ch25-composite-orchestration, ch34-strategy-pattern, ch26-modular-monolith입니다.

확인 환경

Docker 컨테이너(JDK 21.0.11), Spring Boot 4.1.1, ArchUnit 1.4.1입니다. 세 예제 모두 Docker에서 cleanTest test를 실행해 합계 44건(ch25 15건, ch34 12건, ch26 17건)이 통과하는 것을 확인했습니다. Windows는 확인하지 못했습니다.

예제 코드

대상 링크
Composite·Orchestration ch25-composite-orchestration/
전략 패턴 ch34-strategy-pattern/
모듈러 모놀리스 ch26-modular-monolith/
묶음 규칙 CompositeDiscountRule.java
규칙 인터페이스 DiscountRule.java
정책 조립 PricingConfig.java
Composite 테스트 CompositeDiscountRuleTests.java
Orchestrator OrderOrchestrator.java
결제 계약 PaymentService.java
재고 계약 InventoryService.java
Orchestrator 테스트 OrderOrchestratorTests.java
API 테스트 OrderApiTests.java
전략 인터페이스 ShippingFeeStrategy.java
일반 배송 StandardShipping.java
계산기 ShippingFeeCalculator.java
전략 테스트 ShippingStrategyTests.java
API 테스트 ShippingControllerTests.java
주문 서비스 OrderService.java
구조 테스트 ArchitectureTests.java
순환 위반 예제 cycle/
이벤트 타입 OrderPlaced.java
적립 리스너 RewardService.java
트랜잭션 경계 테스트 TransactionBoundaryTests.java
주문 흐름 테스트 OrderFlowTests.java
외부 API 계약 ch18-api-contract/
Port/Adapter ch24-port-adapter/

규칙 하나와 규칙 묶음은 같은 모양입니다

할인 정책이 “VIP는 10%”, “5만 원 이상이면 3천 원”, “첫 주문이면 2천 원”으로 늘어나면 if가 한 메서드에 쌓입니다. 게다가 어떤 할인은 합쳐서 적용하고 어떤 할인은 둘 중 큰 것 하나만 적용해야 합니다. Composite 패턴은 단일 규칙과 규칙 묶음을 같은 인터페이스로 다루게 해서 이 구조를 단순하게 만듭니다.

규칙은 인터페이스 하나

public interface DiscountRule {
    long discount(PricingContext context);
}

public record PricingContext(Grade grade, long amount, boolean firstOrder) { }

규칙 하나하나는 이 인터페이스를 구현합니다.

public class VipRateRule implements DiscountRule {
    @Override
    public long discount(PricingContext context) {
        return context.grade() == Grade.VIP ? context.amount() / 10 : 0;
    }
}
// BulkAmountRule: amount >= 50_000 이면 3_000, FirstOrderRule: firstOrder 이면 2_000

주요 코드 설명

  • PricingContext는 규칙이 판단에 쓰는 주문 정보(등급, 금액, 첫 주문 여부)를 담는 record입니다. 규칙은 이것만 보고 판단하므로 주문 엔티티나 DB를 알 필요가 없습니다.
  • 각 규칙은 해당하지 않으면 0을 돌려줍니다. 규칙을 적용할지 말지의 분기가 규칙 안에 있고, 호출하는 쪽은 그냥 discount()를 부릅니다.

묶음도 같은 인터페이스

public class CompositeDiscountRule implements DiscountRule {

    private final List<DiscountRule> children;
    private final boolean sum;

    public static CompositeDiscountRule sumOf(DiscountRule... rules) { ... }   // 합산
    public static CompositeDiscountRule bestOf(DiscountRule... rules) { ... }  // 최대값 선택

    @Override
    public long discount(PricingContext context) {
        ToLongFunction<DiscountRule> each = rule -> rule.discount(context);
        if (sum) {
            long total = children.stream().mapToLong(each).sum();
            return Math.min(total, context.amount());
        }
        return children.stream().mapToLong(each).max().orElse(0);
    }
}
방식 의미 코드
합산 자식 할인을 모두 더한다. 합계가 주문 금액을 넘으면 주문 금액까지만 sumOf(...)
최대값 선택 자식 중 가장 큰 할인 하나만 적용한다(중복 적용 불가) bestOf(...)

주요 코드 설명

  • CompositeDiscountRule도 DiscountRule을 구현합니다. 그래서 호출하는 쪽은 규칙 하나인지 묶음인지 구별하지 않고 discount()만 부릅니다. 이것이 Composite의 핵심입니다.
  • Math.min(total, context.amount()): 합산이 주문 금액을 넘으면 금액을 마이너스로 만드는 일이 없도록 상한을 둡니다.
  • 정적 팩터리(sumOf, bestOf)로 의도를 이름에 드러냈습니다. 생성자는 private입니다.
  • 묶음 안에 또 묶음을 넣을 수 있어서 정책이 트리가 됩니다.

이 예제의 정책 트리는 루트가 sumOf이고, 그 아래에 VipRateRule과 bestOf가 있으며, bestOf 아래에 BulkAmountRule과 FirstOrderRule이 있습니다.

이 트리는 “VIP 할인은 항상 더하고, 대량 구매와 첫 주문 할인은 둘 중 큰 것 하나만”이라는 정책입니다.

따라 하기

./gradlew :examples:ch25-composite-orchestration:test --tests '*Composite*'

Composite 테스트 6건이 통과합니다. 같은 입력을 손으로 계산한 값과 테스트의 기대값을 비교해 보세요(아래 “손으로 따라가 보기” 절의 계산표).

직접 해 보기

  1. 새 규칙 WeekendRule(주말이면 1,000원)을 만들어 bestOf에 추가하는 코드를 구상해 보세요.
  2. sumOf의 Math.min을 없애면 어떤 입력에서 문제가 생기는지 찾아보세요.
  3. 트리를 sumOf(bestOf(...), bestOf(...)) 형태로 바꾸면 정책이 어떻게 달라지는지 말로 설명해 보세요.

규칙 계약과 정책 조립

DiscountRule.discount() 한 줄이 이 Chapter에서 첫 규칙 계약입니다. “주문 정보를 주면 깎을 금액을 돌려준다”만 약속하고, 규칙이 하나인지 열 개인지, 합산인지 최대값인지는 호출하는 쪽이 모릅니다. 이 절은 정책이 한 곳에서 조립되는 모습과 그 결과 값을 테스트로 고정한 것을 봅니다.

한 곳의 조립

@Bean
DiscountRule discountRule() {
    return CompositeDiscountRule.sumOf(
            new VipRateRule(),
            CompositeDiscountRule.bestOf(new BulkAmountRule(), new FirstOrderRule()));
}

@Bean(Chapter 03)으로 하나의 DiscountRule을 등록합니다. 주문 흐름은 이 인터페이스만 주입받습니다. 정책이 바뀌면 이 한 곳의 조립만 고칩니다. 새 규칙을 추가해도 OrderOrchestrator는 바뀌지 않습니다.

손으로 따라가 보기

주문 계산 할인
VIP, 6만 원, 첫 주문 6,000(VIP) + max(3,000 대량, 2,000 첫 주문) 9,000원
일반 등급, 6만 원, 첫 주문 0 + max(3,000, 2,000) 3,000원 (5,000원이 아님)
VIP, 1,000원, 첫 주문 100 + max(0, 2,000) = 2,100 → 주문 금액 상한 1,000원

두 번째 행이 bestOf의 역할을 보여 줍니다. 대량 구매 할인과 첫 주문 할인을 더하면 5,000원이지만 최대값 선택이라 3,000원만 적용됩니다. 세 번째 행은 합산이 주문 금액을 넘으면 금액까지만 깎는 상한입니다.

Composite 테스트 6건이 이 경우들을 고정하고, API 테스트의 VIP 6만 원 첫 주문 응답에서도 할인 9,000원이 나옵니다. 이 응답은 주문 흐름을 다룰 때 다시 봅니다.

계약으로서 본 DiscountRule

약속 내용
입력 PricingContext(등급, 금액, 첫 주문 여부)
출력 깎을 금액(원), 해당 없으면 0
모르는 것 어떤 규칙이 몇 개 있는지, 합산인지 선택인지

Chapter 12의 표에서 말한 “규칙 계약”이 이것입니다. 이 인터페이스 덕분에 새 규칙을 추가하는 것은 쉽고(구현체 하나 + 조립 한 줄), 호출 코드는 수정하지 않습니다.

한계

규칙 사이의 우선순위나 “이 규칙은 저 규칙과 함께 쓸 수 없다” 같은 복잡한 정책은 이 구조 두 가지(합산, 최대값)로 표현되는 범위까지만 다뤘습니다. 정책 자체를 DB에서 관리하는 방식(규칙 표)은 이 Chapter에서 다루지 않았고, Chapter 17에서 코드로 정의한 호출 규칙과 비교합니다.

확인 문제

  1. VIP, 6만 원, 첫 주문의 할인은 얼마이고 어떻게 계산되나요?
  2. 세 번째 행(VIP, 1,000원, 첫 주문)에서 할인이 2,100이 아닌 1,000인 이유는 무엇인가요?

답: 1) 6,000(VIP 10%) + max(3,000, 2,000) = 9,000원입니다. 2) 합산 결과가 주문 금액을 넘으면 주문 금액까지만 인정하기 때문입니다.

직접 해 보기

  1. 세 번째 행의 계산을 CompositeDiscountRule의 코드에서 한 줄씩 따라가 보세요.
  2. bestOf를 sumOf로 바꾸면 두 번째 행이 어떻게 되는지 계산해 보세요.
  3. 규칙을 @Component로 등록하고 List<DiscountRule>로 주입받는 방식과 @Bean 조립을 비교해 보세요. 이 비교는 아래 “List 주입” 절에서 이어집니다.

주문 흐름은 한 클래스만 압니다

주문은 재고 확보, 결제, 배송 예약이 순서대로 이어지고, 중간에 실패하면 앞의 일을 되돌려야 합니다. 이 순서와 되돌리기가 각 서비스 안에 흩어지면 흐름을 한눈에 볼 수 없습니다. 해법은 서비스는 자기 일만 하고, 순서와 실패 처리는 오직 한 클래스(Orchestrator)에 두는 것입니다.

서비스 계약: 정상, 실패, 보상

public interface PaymentService {
    /** 결제하고 결제 번호를 돌려준다. 거절되면 {@link PaymentDeclinedException}. */
    String charge(String customerId, long amount);
    /** 결제를 취소한다(보상). */
    void refund(String paymentId);
}

public interface InventoryService {
    /** 재고를 확보한다. 부족하면 {@link OutOfStockException}. */
    void reserve(String sku, int quantity);
    /** 확보했던 재고를 되돌린다(보상). */
    void release(String sku, int quantity);
}

각 인터페이스의 계약에는 세 가지가 들어 있습니다: 정상 동작(charge), 실패의 모양(거절되면 PaymentDeclinedException), 보상(refund). 보상을 계약에 넣은 것이 핵심입니다. “되돌릴 수 있는 일만 한다”는 약속이 있어야 Orchestrator가 안전하게 실패를 처리할 수 있습니다. 배송은 ShippingService.schedule로 같은 모양입니다.

Orchestrator

@Service
public class OrderOrchestrator {
    // 할인 규칙, 재고, 결제, 배송 서비스를 주입받는다

    public OrderResult place(PlaceOrderCommand cmd) {
        long amount = cmd.unitPrice() * cmd.quantity();
        long discount = discountRule.discount(new PricingContext(cmd.grade(), amount, cmd.firstOrder()));
        long payable = amount - discount;
        long orderId = orderSequence.incrementAndGet();
        try {
            inventory.reserve(cmd.sku(), cmd.quantity());                  // 1. 재고
        } catch (RuntimeException e) {
            throw new OrderFailedException("재고", e);
        }
        String paymentId;
        try {
            paymentId = payment.charge(cmd.customerId(), payable);         // 2. 결제
        } catch (RuntimeException e) {
            inventory.release(cmd.sku(), cmd.quantity());                  //    실패하면 재고 반환
            throw new OrderFailedException("결제", e);
        }
        String trackingNo;
        try {
            trackingNo = shipping.schedule(orderId, cmd.customerId());     // 3. 배송
        } catch (RuntimeException e) {
            payment.refund(paymentId);                                     //    결제 취소 -> 재고 반환
            inventory.release(cmd.sku(), cmd.quantity());                  //    (일어난 순서의 반대)
            throw new OrderFailedException("배송", e);
        }
        return new OrderResult(orderId, amount, discount, payable, paymentId, trackingNo);
    }
}

주요 코드 설명

  • 첫 줄들은 앞의 “한 곳의 조립” 절에서 등록한 DiscountRule로 결제 금액을 계산합니다.
  • 재고 단계에서 실패하면 되돌릴 것이 없습니다. 아직 아무 일도 하지 않았기 때문입니다.
  • 결제에서 실패하면 이미 확보한 재고를 돌려줍니다(release).
  • 배송에서 실패하면 결제 취소가 먼저, 재고 반환이 그다음입니다. 일어난 순서의 반대로 되돌리는 것이 원칙입니다. 재고를 먼저 풀면 취소 중에 다른 주문이 그 재고를 가져갈 수 있는 틈이 생깁니다(이 틈의 영향은 이 Chapter에서 실험하지 않았고 일반적인 이유입니다).
  • 실패는 OrderFailedException("단계", 원인)으로 통일해, 웹 계층이 단계에 따라 상태 코드(재고 409, 결제 402)를 정합니다.
  • 각 서비스는 서로를 부르지 않습니다. 흐름은 오직 이 클래스에 있어서, 단계가 하나 더 생기면 여기서 순서와 되돌리는 방법을 한꺼번에 보면 됩니다.

이 방식은 한 프로세스 안에서 순서대로 호출하는 단순한 Orchestration입니다. 서비스 호출이 여러 프로세스에 걸치는 분산 환경의 보상(사가 패턴 등)은 다루지 않았습니다. 이 구조가 Chapter 17에서 “모듈 호출 오케스트레이션”으로 확장됩니다.

따라 하기

./gradlew :examples:ch25-composite-orchestration:test

재검증에서 Docker로 cleanTest test를 다시 실행해 15건(Composite 6, Orchestrator 4, API 4, 컨텍스트 1)이 모두 통과했습니다.

단계별로 무엇을 되돌리나

실패 단계 이미 한 일 되돌리는 순서
재고 없음 없음
결제 재고 확보 재고 반환
배송 재고 확보, 결제 결제 취소 → 재고 반환

확인 문제

  1. 재고 단계에서 실패하면 보상이 필요한가요?
  2. 흐름을 한 클래스에 두는 이유는 무엇인가요?

답: 1) 아직 한 일이 없어 필요 없습니다. 2) 단계가 늘거나 바뀔 때 고칠 곳이 한 곳이 되고, 서비스는 서로를 몰라도 되기 때문입니다.

직접 해 보기

  1. 새 단계 “포인트 사용”을 결제 앞에 추가한다면 보상 코드를 어디에 어떻게 넣을지 적어 보세요.
  2. 배송 실패에서 refund와 release의 순서를 바꾸면 어떤 위험이 생길지 생각해 보세요.
  3. 보상 도중 refund가 실패하면 어떻게 될지 예측해 보세요(이 예제는 다루지 않습니다).

보상 순서를 기록하는 가짜로 검사합니다

보상 로직은 실패한 경로에서만 실행되므로 평소 테스트에는 걸리지 않습니다. 그래서 가장 비싼 실수(돈은 받았는데 상품은 안 보냄)가 가장 조용합니다. 이 절은 서비스 세 개를 호출 이름을 리스트에 남기는 가짜로 바꿔 호출 순서 자체를 비교하는 테스트와, 보상 한 줄을 빼 본 실험 결과를 정리합니다.

호출을 기록하는 가짜

Orchestrator 테스트는 세 서비스를 호출 이름을 리스트에 남기는 가짜로 바꿔 끼웁니다. 그리고 호출 목록 자체를 비교합니다. Chapter 15의 가짜 구현과 같은 기법입니다.

상황 기록된 호출
성공 reserve:BOOKx2, charge:19000, ship:1
재고 부족 reserve:BOOKx2 (그 뒤로 아무것도 부르지 않음)
결제 거절 reserve:BOOKx2, charge:19000, release:BOOKx2
배송 실패 reserve:BOOKx2, charge:19000, ship:1, refund:PAY-1, release:BOOKx2

마지막 줄이 핵심입니다. 배송이 실패하면 결제 취소가 먼저, 재고 반환이 그다음이어야 합니다. 순서가 바뀌면 이 테스트가 실패합니다. 테스트는 Orchestrator 4건입니다.

실제 응답

JAR를 띄워 요청한 결과입니다. 재고는 BOOK 5개, PEN 0개이고, 결제는 100만 원을 넘으면 거절하는 흉내용 구현입니다.

POST /api/orders {"customerId":"c1","grade":"VIP","sku":"BOOK","quantity":2,"unitPrice":30000,"firstOrder":true}
  -> 201 {"orderId":1,"amount":60000,"discount":9000,"payable":51000,"paymentId":"PAY-1","trackingNo":"TRK-1"}
POST /api/orders {... "grade":"NORMAL","sku":"PEN","quantity":1,"unitPrice":1000 ...}
  -> 409 {"message":"재고 단계에서 실패했습니다: 재고가 부족합니다: PEN","step":"재고"}
POST /api/orders {... "grade":"NORMAL","sku":"BOOK","quantity":1,"unitPrice":2000000 ...}
  -> 402 {"message":"결제 단계에서 실패했습니다: 결제가 거절되었습니다: 1997000","step":"결제"}

첫 응답의 할인 9,000원이 앞의 “손으로 따라가 보기” 절의 계산과 같습니다. 실패한 단계에 따라 상태 코드를 나눴습니다. 재고는 409, 결제는 402입니다. 결제 거절 뒤 BOOK 재고가 원래대로 돌아오는 것은 API 테스트가 확인합니다. 수량 0은 400이었습니다.

보상 한 줄을 빼 본 실험

아래는 이 예제에서 보상 한 줄을 빼 얻은 결과입니다. 바꾼 코드는 되돌렸고 저장소에는 올리지 않았습니다.

1. 결제 실패 뒤 재고가 돌아오지 않는다

결제가 거절됐을 때의 inventory.release(...)를 지웠습니다. 15건 중 2건이 실패했습니다.

declinedPaymentIs402AndStockIsRestored()
AssertionFailedError: expected: <5> but was: <4>
declinedPaymentReleasesInventory()
expected: <[reserve:BOOKx2, charge:19000, release:BOOKx2]> but was: <[reserve:BOOKx2, charge:19000]>

응답 코드는 정상(402)이라 눈으로는 보이지 않고, 호출 기록과 남은 재고를 검사해야 드러납니다.

2. 배송 실패 뒤 결제가 취소되지 않는다

배송 실패 때의 payment.refund(paymentId)를 지웠습니다. 1건이 실패했습니다.

shippingFailureRefundsThenReleasesInReverseOrder()
expected: <[reserve:BOOKx2, charge:19000, ship:1, refund:PAY-1, release:BOOKx2]> but was: <[reserve:BOOKx2, charge:19000, ship:1, release:BOOKx2]>

돈은 받았는데 상품은 보내지 않은 상태입니다. 기록된 순서를 한 줄씩 비교하면 refund:PAY-1이 빠진 것이 바로 보입니다.

증상 가장 먼저 볼 것
실패 응답인데 재고나 잔액이 틀림 해당 실패 분기의 되돌리기 호출
호출 기록에서 항목이 빠짐 기대한 순서와 실제 순서를 한 줄씩 비교
보상이 일부만 실행됨 보상 중 예외, try/catch 범위

지금의 한계

위 테스트들은 한 번씩 실패하는 시나리오만 확인합니다. 배송 실패의 HTTP 응답(500 등)은 API 테스트로 확인하지 않았습니다(흉내용 배송 서비스는 실패하지 않습니다). 보상 도중에 또 실패하는 경우(환불 실패), 동시 요청에서의 재고 정확성은 다루지 않았습니다.

어떤 기록이 정상인가

실제 서비스를 부르지 않고, 호출 이름을 리스트에 남긴 뒤 기대 목록과 비교합니다. 목록 한 줄이 빠지면 어느 단계의 보상이 사라졌는지 바로 보입니다.

직접 해 보기

  1. 기록 가짜에서 호출 이름을 한 개 더 남기도록 바꿔 보세요(예: 수량).
  2. 보상 줄을 직접 하나 지우고 어떤 테스트가 실패하는지 확인한 뒤 복원하세요.
  3. “응답 코드는 정상인데 상태가 틀리다”는 종류의 버그가 자신의 프로젝트에 있을 수 있는 곳을 찾아보세요.

if/else를 전략으로 바꿉니다

여기부터는 같은 Chapter의 다른 주제인 전략 패턴입니다. if/else를 구현체 추가로 바꿔 봅니다.

배송 방법이 일반, 빠른, 매장 수령으로 늘어나면 배송비 계산 메서드는 이렇게 자라기 쉽습니다(설명용 코드입니다).

long fee(String method, long amount, int weightKg) {
    if (method.equals("standard")) {
        return amount >= 50_000 ? 0 : 3_000;
    } else if (method.equals("express")) {
        return 5_000 + Math.max(0, weightKg - 2) * 500;
    } else if (method.equals("pickup")) {
        return 0;
    }
    throw new IllegalArgumentException("지원하지 않는 방법: " + method);
}

배송 방법이 하나 늘 때마다 이 메서드를 열어 else if를 추가해야 합니다. 방법별 규칙이 복잡해질수록 한 메서드가 커지고, 한 방법을 고치다 다른 방법을 건드릴 위험도 있습니다. 전략 패턴은 방법마다 구현 클래스를 하나씩 두고 계산기는 고르기만 하게 합니다.

전략 인터페이스와 구현

public interface ShippingFeeStrategy {
    String key();
    long fee(ShippingRequest request);
}

public record ShippingRequest(long orderAmount, int weightKg) {
    public ShippingRequest {
        if (orderAmount < 0 || weightKg < 0) {
            throw new IllegalArgumentException("금액과 무게는 0 이상이어야 합니다.");
        }
    }
}
@Component
class StandardShipping implements ShippingFeeStrategy {
    static final long BASE_FEE = 3_000;
    static final long FREE_THRESHOLD = 50_000;

    @Override public String key() { return "standard"; }

    @Override
    public long fee(ShippingRequest request) {
        return request.orderAmount() >= FREE_THRESHOLD ? 0 : BASE_FEE;
    }
}

ExpressShipping은 기본 5,000원에 2kg을 넘는 무게 1kg마다 500원을 더하고, PickupShipping은 항상 0원입니다.

주요 코드 설명

  • key(): 요청에서 방법을 고르는 이름("standard")입니다. 구현체가 자기 이름을 스스로 밝힙니다.
  • fee(request): 그 방법의 계산 규칙입니다. 방법별 규칙은 자기 클래스 안에만 있습니다.
  • 구현체는 @Component로 등록되고 패키지 전용(class)입니다. 외부는 인터페이스만 압니다.
  • ShippingRequest는 record이고, 생성자에서 음수를 막습니다(컴팩트 생성자). 잘못된 값은 만들어지는 순간 거절되므로 전략들은 검증을 신경 쓰지 않아도 됩니다.
  • 계산 규칙이 상수로 클래스에 드러나 있습니다: 일반은 5만 원 이상 무료, 빠른 배송은 2kg까지 기본.
방법 규칙 예
standard 기본 3,000원, 5만 원 이상 무료 49,999원 → 3,000, 50,000원 → 0
express 기본 5,000원 + 2kg 초과 1kg당 500원 2kg → 5,000, 5kg → 6,500
pickup 무료 항상 0

위 표의 예는 ShippingStrategyTests가 그대로 고정한 값입니다.

전략 선택

@Service
public class ShippingFeeCalculator {

    private final Map<String, ShippingFeeStrategy> strategies;

    public ShippingFeeCalculator(List<ShippingFeeStrategy> strategyList) {
        this.strategies = strategyList.stream()
                .collect(Collectors.toUnmodifiableMap(ShippingFeeStrategy::key, Function.identity()));
    }

    public long calculate(String method, ShippingRequest request) {
        ShippingFeeStrategy strategy = strategies.get(method);
        if (strategy == null) {
            throw new UnknownShippingMethodException(method, new TreeSet<>(strategies.keySet()));
        }
        return strategy.fee(request);
    }
}

계산기에는 방법별 if/else가 없습니다. 맵에서 이름으로 고르고 호출만 합니다. 이 구조의 핵심은 “새 방법이 계산기를 바꾸지 않는다”입니다. Spring이 전략을 어떻게 모아 주는지는 아래 “List 주입” 절에서 자세히 봅니다.

따라 하기

./gradlew :examples:ch34-strategy-pattern:bootRun
curl "http://localhost:8080/api/shipping/fee?method=standard&orderAmount=49999"
curl "http://localhost:8080/api/shipping/fee?method=standard&orderAmount=50000"
curl "http://localhost:8080/api/shipping/fee?method=express&orderAmount=30000&weightKg=5"
{"method":"standard","fee":3000}
{"method":"standard","fee":0}
{"method":"express","fee":6500}

직접 해 보기

  1. DawnShipping(새벽 배송, 7,000원 고정)을 @Component로 추가하고 계산기를 수정하지 않아도 되는지 확인해 보세요.
  2. 위 설명용 if/else 코드에 새 방법을 추가할 때 고쳐야 하는 곳과 비교해 보세요.
  3. 전략마다 key()를 두는 대신 enum으로 선택하는 방법의 장단점을 생각해 보세요.

전략은 Spring이 모아 줍니다

전략 구현체가 @Component로 여러 개 등록되어 있을 때, 계산기는 그것들을 어떻게 한꺼번에 받을까요? Chapter 03에서 배운 List 주입이 바로 이 용도입니다. 이 절은 List<ShippingFeeStrategy> 주입, 중복 key 방어, 그리고 스프링 없이도 전략을 조립해 테스트하는 방법을 정리합니다.

List 주입

public ShippingFeeCalculator(List<ShippingFeeStrategy> strategyList) {
    this.strategies = strategyList.stream()
            .collect(Collectors.toUnmodifiableMap(ShippingFeeStrategy::key, Function.identity()));
}

주요 코드 설명

  • 생성자 파라미터 List<ShippingFeeStrategy>: 스프링이 ShippingFeeStrategy를 구현한 모든 Bean을 리스트로 모아 넣어 줍니다.
  • Collectors.toUnmodifiableMap(키, 값): 리스트를 key() → 전략 맵으로 바꿉니다. 맵은 수정할 수 없습니다.
  • 새 구현체를 @Component로 등록하면 이 리스트에 자동으로 들어옵니다. 계산기 코드는 그대로입니다.
  • 방법 이름 목록은 맵에서 뽑아 정렬합니다(methods()). 그래서 /api/shipping/methods 응답이 Bean 등록 순서에 의존하지 않고 ["express","pickup","standard"]로 일정합니다.

같은 key가 둘이면 기동하지 않는다

두 구현체가 같은 key()를 돌려주면 toUnmodifiableMap이 예외를 던지고, 이 예외는 Bean 생성 중이므로 애플리케이션이 뜨지 않습니다. 테스트가 이를 고정합니다.

@Test
void duplicateKeysFailAtStartup() {
    assertThrows(IllegalStateException.class, () -> new ShippingFeeCalculator(
            List.of(new StandardShipping(), new StandardShipping())));
}

“조용히 하나가 다른 하나를 덮어쓰는 것”보다 기동 실패가 낫습니다. 어떤 전략이 쓰일지 불분명한 상태로 운영되는 것을 막기 때문입니다. 예외 메시지의 정확한 문구는 확인하지 않았고, 타입(IllegalStateException)만 테스트가 확인합니다.

스프링 없이 조립해서 테스트

private final ShippingFeeCalculator calculator = new ShippingFeeCalculator(
        List.of(new StandardShipping(), new ExpressShipping(), new PickupShipping()));

List.of(...)로 직접 만들어 넣으면 스프링 컨테이너 없이 계산기를 시험합니다. 새 전략이 계산기를 바꾸지 않는 것도 이렇게 증명합니다.

ShippingFeeStrategy dawn = new ShippingFeeStrategy() {
    @Override public String key() { return "dawn"; }
    @Override public long fee(ShippingRequest request) { return 7_000; }
};
ShippingFeeCalculator extended = new ShippingFeeCalculator(
        List.of(new StandardShipping(), new ExpressShipping(), new PickupShipping(), dawn));

assertEquals(7_000, extended.calculate("dawn", new ShippingRequest(1_000, 1)));
assertEquals(List.of("dawn", "express", "pickup", "standard"), extended.methods());

알 수 없는 방법을 요청하면 사용 가능한 이름을 알려 주는 메시지가 나옵니다.

지원하지 않는 배송 방법입니다: drone (사용 가능: [express, pickup, standard])

API 테스트와 결과

요청 결과
method=standard&orderAmount=30000 200, fee 3000
method=express&orderAmount=30000&weightKg=5 200, fee 6500
/api/shipping/methods ["express","pickup","standard"] (Bean에서 발견)
method=drone&orderAmount=1000 400, 메시지에 지원하지 않는 배송 방법입니다: drone

테스트는 전략 7건(ShippingStrategyTests), 컨트롤러 4건, 컨텍스트 1건으로 12건이 모두 통과했습니다. 컨트롤러가 UnknownShippingMethodException과 IllegalArgumentException을 400으로 바꾸는 방식은 Chapter 15와 같습니다.

따라 하기

curl http://localhost:8080/api/shipping/methods
curl -i "http://localhost:8080/api/shipping/fee?method=drone&orderAmount=1000"
["express","pickup","standard"]
HTTP/1.1 400   {"message":"지원하지 않는 배송 방법입니다: drone (사용 가능: [express, pickup, standard])"}

확인 문제

  1. 같은 key()를 가진 전략이 둘이면 왜 기동 실패가 낫나요?
  2. 계산기를 스프링 없이 테스트할 수 있는 이유는 무엇인가요?

답: 1) 어떤 전략이 쓰일지 불분명한 상태로 조용히 동작하는 것보다 즉시 알려 주기 때문입니다. 2) 생성자가 List를 받으므로 List.of(...)로 직접 조립할 수 있기 때문입니다.

직접 해 보기

  1. StandardShipping과 같은 key를 가진 구현체를 @Component로 하나 더 만들어 기동 실패를 확인하세요(복원).
  2. /api/shipping/methods가 정렬되어 나오는 이유를 코드에서 찾아보세요.
  3. 전략 선택 이름을 요청 파라미터가 아니라 사용자의 설정에서 가져오면 어떤 변화가 있을지 생각해 보세요.

Composite, 전략, Orchestration은 언제 쓰나

세 가지 도구는 모두 “if가 쌓이는 문제”를 푸는 것처럼 보이지만 푸는 문제가 다릅니다. 이 절은 세 도구를 같은 틀로 비교하고, 어떤 신호가 있을 때 무엇을 고를지 정리합니다. 새로운 코드는 없고 앞의 두 예제를 한 표로 묶는 절입니다.

한 표로 비교

구분 Composite 전략(Strategy) Orchestration
푸는 문제 규칙 여러 개를 조합해서 한 값을 구한다 여러 방법 중 하나를 골라 실행한다 여러 서비스를 순서대로 부르고 실패를 되돌린다
호출 쪽이 아는 것 규칙 하나인지 묶음인지 모름 이름(key) 흐름 전체(한 클래스)
예 할인 정책 트리 배송비 계산 재고 → 결제 → 배송
확장 규칙 추가 + 조립 한 줄 구현체 추가 단계 추가 + 보상 추가
위험 조립이 복잡해지면 읽기 어렵다 이름 오타, key 중복 보상 누락이 조용히 지나간다
코드 CompositeDiscountRule ShippingFeeStrategy + 계산기 OrderOrchestrator

선택 신호

다음 질문으로 고릅니다.

  1. 결과가 여러 규칙의 합이나 최대로 만들어지는가? → Composite.
  2. 같은 입력으로 여러 구현 중 하나만 실행되는가? → 전략.
  3. 여러 협력자를 순서대로 부르고, 중간 실패 시 앞의 일을 되돌려야 하는가? → Orchestration.
  4. 셋 다 아니고 분기가 두세 개로 안정적이라면 → 그냥 if/switch로 둡니다.

서로 섞어 쓰기

세 가지는 함께 쓰이기도 합니다. 이 Chapter의 OrderOrchestrator가 DiscountRule(Composite 정책)로 금액을 구한 뒤 재고·결제·배송을 부르는 것이 그 예입니다. 전략은 구현체 선택이 필요할 때 Orchestrator 안의 한 단계로 들어갈 수도 있습니다(이 예제에서 합쳐 보지는 않았습니다).

과설계 주의

패턴은 변하는 것을 감쌀 때 가치가 있습니다. 배송 방법이 두 개로 고정이고 앞으로도 바뀔 일이 없다면 전략 클래스 세 개는 오히려 읽기 어렵습니다. 이 과정의 원칙처럼 불필요한 복잡도를 더하지 않는 것이 먼저입니다. 이 기준은 일반적인 설계 지침이며 이 저장소에서 측정한 결과는 아닙니다.

직접 해 보기

  1. 자신의 프로젝트에서 if가 많은 메서드 하나를 골라 세 신호 중 어디에 해당하는지 분류해 보세요.
  2. 세 가지가 모두 필요 없는 경우라면 무엇이 그 신호인지 적어 보세요.
  3. 이 Chapter의 예제 중 가장 “과해 보이는” 부분은 어디인지, 그리고 그 이유를 말해 보세요.

모듈은 api와 internal을 가집니다

여기부터는 코드를 모듈로 나누는 이야기입니다.

서비스를 마이크로서비스로 쪼개기 전에, 하나의 애플리케이션 안에서 경계부터 지키는 방법이 있습니다. 모듈러 모놀리스입니다. 배포는 하나지만 코드는 회원, 상품, 주문, 적립 같은 모듈로 나누고, 모듈 사이는 정해진 입구로만 오갑니다. 문제는 “정해진 입구로만”을 사람의 약속에 맡기면 금방 무너진다는 것입니다. 이 절은 모듈의 구조를 보고, 약속을 코드와 규칙으로 바꿉니다.

네 모듈

member   api: MemberApi            internal: JdbcMemberDirectory
catalog  api: CatalogApi           internal: InMemoryCatalog
order    api: OrderApi, OrderPlaced internal: OrderService, OrderController
reward   api: RewardApi            internal: RewardService

api는 다른 모듈이 써도 되는 인터페이스와 값, internal은 구현입니다.

/** member 모듈이 다른 모듈에 공개하는 유일한 입구. */
public interface MemberApi {
    boolean exists(long memberId);
}

public interface CatalogApi {
    Optional<Long> priceOf(String sku);
}

public interface OrderApi {
    OrderPlaced place(long memberId, String sku, int quantity);
}

주요 코드 설명

  • 각 api의 인터페이스가 그 모듈의 공개 계약입니다. Chapter 12의 contract 패키지와 같은 발상이 모듈 단위로 나타났습니다.
  • 계약은 작습니다. MemberApi는 “이 회원이 있는가” 하나만 공개합니다. 회원 테이블 구조나 조회 방법은 보이지 않습니다.
  • internal의 클래스는 public이 아니라 패키지 전용입니다.
@Service
class OrderService implements OrderApi { ... }

다른 모듈이 OrderService를 import하려 하면 컴파일 단계에서 막힙니다. 그래도 누군가 public을 붙이는 실수를 할 수 있어서 규칙으로도 막았습니다(아래 “ArchUnit 규칙으로 고정” 절). 컴파일러가 1차, ArchUnit이 2차 방어입니다.

주문 모듈이 다른 모듈을 쓰는 방식

@Override
@Transactional
public OrderPlaced place(long memberId, String sku, int quantity) {
    if (!members.exists(memberId)) {
        throw new UnknownMemberException(memberId);
    }
    long unitPrice = catalog.priceOf(sku).orElseThrow(() -> new UnknownProductException(sku));
    ...
}

OrderService는 MemberApi와 CatalogApi라는 인터페이스로만 상대 모듈을 부릅니다. 회원이 JDBC로 저장되든 메모리에 있든 주문 모듈은 모릅니다. Chapter 15의 Port와 비슷한 구조로, 차이는 상대가 외부 시스템이 아니라 같은 애플리케이션의 다른 모듈이라는 점입니다.

실제 응답

POST /api/orders {"memberId":1,"sku":"BOOK","quantity":2}
  -> 201 {"orderId":1,"memberId":1,"payable":30000}
POST /api/orders {"memberId":999,"sku":"BOOK","quantity":1}
  -> 404 {"message":"존재하지 않는 회원입니다: 999"}
POST /api/orders {"memberId":1,"sku":"NOPE","quantity":1}
  -> 404 {"message":"존재하지 않는 상품입니다: NOPE"}

없는 회원으로 주문하면 404이고 주문 행도 적립도 남지 않습니다. 모듈별 테이블 소유(각 모듈이 자기 테이블만 쓴다)는 약속일 뿐 테스트가 없습니다.

따라 하기

./gradlew :examples:ch26-modular-monolith:bootRun
curl -i -X POST http://localhost:8080/api/orders -H 'Content-Type: application/json' \
  -d '{"memberId":1,"sku":"BOOK","quantity":2}'
curl -i -X POST http://localhost:8080/api/orders -H 'Content-Type: application/json' \
  -d '{"memberId":999,"sku":"BOOK","quantity":1}'
HTTP/1.1 201  {"orderId":1,"memberId":1,"payable":30000}
HTTP/1.1 404  {"message":"존재하지 않는 회원입니다: 999"}

직접 해 보기

  1. MemberApi에 메서드를 하나 추가하면 어떤 모듈이 영향을 받을지 생각해 보세요.
  2. internal의 클래스를 public으로 바꾸고 컴파일은 되는지 확인한 뒤 복원하세요.
  3. 자신의 프로젝트에서 “모듈”로 나눌 수 있는 기능 두 가지를 골라 api에 무엇을 공개할지 적어 보세요.

순환 참조를 막는 의존 방향

모듈이 늘면 서로를 가리키는 순환이 가장 먼저 생깁니다. A가 B를 알고 B가 A를 알면 둘은 따로 바꾸거나 따로 테스트할 수 없는 한 덩어리입니다. 이 절은 주문 완료 뒤 적립이라는 요구에서 순환이 어떻게 생기고, 모듈 구조로 어떻게 피했는지, 그리고 그 구조를 ArchUnit 규칙으로 어떻게 고정했는지 봅니다.

순환이 생기는 경위

적립을 주문 안에 넣거나 회원 모듈에 넣는 쪽이 더 쉬워 보입니다. 하지만 적립을 회원 모듈에 넣으면 이렇게 됩니다.

  • 주문은 회원 확인을 위해 member.api를 부릅니다. (order → member)
  • 회원 모듈이 주문 이벤트를 듣기 위해 order.api를 참조합니다. (member → order)

두 모듈이 서로를 가리키는 순환이 됩니다. 순환이 생기면 한쪽만 수정·테스트·분리하기 어렵습니다. 적립을 별도 모듈로 두면 순환이 사라집니다.

모듈 아는 모듈
member 없음
catalog 없음
order member.api, catalog.api
reward order.api (주문 이벤트 OrderPlaced)

order는 reward를 모르고, reward만 order.api를 향합니다. 방향이 한쪽으로만 흐릅니다.

주문 모듈은 적립을 호출하지 않고 사실(이벤트)만 알립니다. 누가 듣는지 모릅니다. 이 이벤트가 어떻게 전달되는지는 아래 “수신: 커밋된 뒤에만” 절에서 봅니다.

ArchUnit 규칙으로 고정

이 구조를 ArchUnit 테스트 8건이 고정합니다.

규칙 의미
모듈 슬라이스에 순환이 없다 slices().matching(...).should().beFreeOfCycles()
다른 모듈은 internal을 쓰지 않는다 네 모듈 각각에 대해 검사
internal의 최상위 클래스는 public이 아니다 가시성 규칙
허용된 모듈 의존만 있다 member와 catalog는 아무 모듈도 모르고, order는 reward를 모르고, reward는 member와 catalog를 모른다
api는 자기 internal을 쓰지 않는다 입구가 구현에 묶이지 않게
모듈마다 api와 internal에 클래스가 있다 규칙이 빈 패키지를 검사하며 통과하는 것을 막는다

핵심 두 개를 코드로 봅니다.

private static ArchRule modulesAreFreeOfCycles(String slicePattern) {
    return slices().matching(slicePattern).should().beFreeOfCycles();
}

private static ArchRule internalIsNotPublic(String internalPackage) {
    return classes().that().resideInAPackage(internalPackage)
            .and().areTopLevelClasses()
            .should().notBePublic();
}

@Test
void modulesHaveNoCycles() {
    modulesAreFreeOfCycles(BASE + ".(*)..").check(production);
}

주요 코드 설명

  • slices().matching("...ch26.(*).."): 패키지를 괄호로 묶은 부분(member, order 등)별 슬라이스로 나누고, beFreeOfCycles()로 슬라이스 사이에 순환이 없음을 검사합니다.
  • internalIsNotPublic: internal 패키지의 최상위 클래스가 public이면 위반입니다. 컴파일러가 막는 것을 규칙으로 한 번 더 막습니다.
  • 다른 모듈의 internal을 쓰지 못하게 하는 규칙은 네 모듈에 대해 반복문으로 적용합니다.

규칙이 잡는지는 위반 예제로 확인

서로를 참조하는 두 패키지(fixture.cycle.a, fixture.cycle.b)에 순환 규칙을 걸면 위반이 나오고, public 클래스를 가진 internal 패키지(fixture.exposed.internal)에 가시성 규칙을 걸면 위반이 나옵니다. 두 테스트 모두 통과했습니다. 이는 Chapter 12와 Chapter 15에서 본 “규칙 자체를 검증한다”와 같은 원칙입니다.

구조 테스트가 8건이고, 주문 흐름 5건, 트랜잭션 경계 3건, 컨텍스트 1건을 합쳐 17건이 모두 통과했습니다. 이 원칙은 같은 서비스 안의 순환(빈 순환 참조)과도 연결됩니다. 스프링 빈 사이의 순환 참조는 생성자 주입에서 기동 실패로 나타나며, 이 Chapter에서는 그 오류 메시지를 재현하지 않았습니다.

따라 하기

./gradlew :examples:ch26-modular-monolith:test --tests '*Architecture*'

구조 테스트 8건이 통과합니다.

직접 해 보기

  1. member.internal이 order.api를 참조하게 임시로 만들고 어떤 규칙이 실패하는지 확인하세요(복원).
  2. 적립을 회원 모듈에 두는 대안의 장단점을 적어 보세요.
  3. 자신의 프로젝트에서 서로를 import하는 두 패키지를 찾아보세요.

이벤트는 커밋된 뒤에만 도착합니다

모듈 사이를 직접 호출 대신 이벤트로 이으면 발행하는 쪽은 듣는 쪽을 모릅니다. 하지만 주문이 아직 확정되지 않았는데 적립이 먼저 일어나면 곤란합니다. 이 절은 OrderPlaced 이벤트가 주문 트랜잭션이 커밋된 뒤에만 도착하게 하는 방법을 봅니다.

이벤트 계약

/** 주문이 만들어졌음을 알리는 사실(event). 다른 모듈이 이 타입만 알면 주문에 반응할 수 있다. */
public record OrderPlaced(long orderId, long memberId, long payable) { }

OrderPlaced는 order.api에 있고, 이것이 이벤트 계약입니다. 발행하는 쪽과 듣는 쪽이 공유하는 것은 이 타입 하나입니다. 발행자는 누가 듣는지 모르고, 듣는 쪽은 order.internal을 모릅니다.

발행: 한 트랜잭션 안에서

@Override
@Transactional
public OrderPlaced place(long memberId, String sku, int quantity) {
    ...
    jdbc.sql("INSERT INTO orders (member_id, sku, quantity, payable) VALUES (:m, :s, :q, :p)")
            .param("m", memberId).param("s", sku).param("q", quantity).param("p", payable)
            .update(keys, "id");
    long orderId = keys.getKey().longValue();
    OrderPlaced placed = new OrderPlaced(orderId, memberId, payable);
    events.publishEvent(placed);
    return placed;
}

주문 저장과 이벤트 발행은 place의 한 트랜잭션 안에서 일어납니다(Chapter 09의 트랜잭션). 생성 키는 GeneratedKeyHolder로 받습니다. 첫 구현의 SELECT MAX(id)는 동시 요청에서 틀릴 수 있어 바꿨습니다.

수신: 커밋된 뒤에만

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional(propagation = Propagation.REQUIRES_NEW)
void onOrderPlaced(OrderPlaced event) {
    long points = event.payable() / 100;
    int updated = jdbc.sql("UPDATE reward SET points = points + :p WHERE member_id = :m")
            .param("p", points).param("m", event.memberId()).update();
    if (updated == 0) {
        jdbc.sql("INSERT INTO reward (member_id, points) VALUES (:m, :p)")
                .param("m", event.memberId()).param("p", points).update();
    }
}
  • @TransactionalEventListener(AFTER_COMMIT): 발행한 쪽의 트랜잭션이 커밋된 뒤에만 호출됩니다. 롤백되면 호출되지 않습니다.
  • 결제 금액의 1%를 적립합니다. 행이 없으면 새로 넣는 간단한 upsert입니다.
  • REQUIRES_NEW는 아래 “REQUIRES_NEW를 붙인 이유와 확인하지 못한 점” 절에서 설명합니다.

테스트로 확인한 시점

상황 결과
이벤트를 발행했지만 아직 커밋 전 적립은 일어나지 않았다
커밋된 뒤 100점(10,000원의 1%)이 적립됐다
트랜잭션이 롤백됨 리스너가 호출되지 않아 적립이 그대로다
바깥 트랜잭션 안에서 place를 호출하고 롤백 주문 행도 사라지고 적립도 없다

마지막 행은 place의 @Transactional이 바깥 트랜잭션에 참여하기 때문입니다. 주문이 만들어졌더라도 바깥 작업이 실패하면 주문까지 함께 취소됩니다. 30,000원 주문에 300점이 쌓이는 것은 주문 흐름 테스트가 RewardApi로 확인합니다. 적립 점수는 조회 API가 없어 JAR 응답에는 나오지 않습니다.

정리하면 시간 순서는 이렇습니다.

  1. OrderService가 트랜잭션 안에서 orders에 행을 넣습니다.
  2. OrderPlaced를 발행합니다. 이때 RewardService는 아직 호출되지 않습니다.
  3. 주문 트랜잭션이 커밋됩니다.
  4. 커밋 뒤에 RewardService가 호출되어 새 트랜잭션에서 reward를 갱신합니다.

REQUIRES_NEW를 붙인 이유와 확인하지 못한 점

리스너에 REQUIRES_NEW를 붙인 근거는 Spring의 TransactionSynchronization.afterCommit 문서입니다. 이 시점에는 트랜잭션이 이미 커밋됐지만 트랜잭션 자원이 아직 열려 있을 수 있어서, 그 안의 데이터 접근이 이미 끝난 원래 트랜잭션에 “참여”하게 되고 더는 커밋되지 않을 수 있다고 설명합니다. 그리고 트랜잭션이 필요한 작업은 PROPAGATION_REQUIRES_NEW로 실행하라고 안내합니다.

그런데 REQUIRES_NEW 줄을 지우고 테스트를 다시 돌려 보니 8건(OrderFlowTests와 TransactionBoundaryTests)이 모두 통과했습니다. 이 예제에서는 적립이 정상적으로 저장된다는 뜻입니다. 왜 그런지는 확인하지 못했습니다. 문서의 안내가 틀렸다고 판단할 근거는 없으므로, 예제에는 안내대로 REQUIRES_NEW를 남겼습니다. 이 조합에서 안내가 필요한지는 직접 실험해 보지 않은 영역입니다.

확인 문제

  1. AFTER_COMMIT 리스너는 롤백되면 호출되나요?
  2. 결제 금액 10,000원이면 적립은 몇 점인가요?

답: 1) 호출되지 않습니다. 2) 1%인 100점입니다.

직접 해 보기

  1. 리스너에서 System.out.println으로 호출 시점을 출력해 커밋 전후를 관찰하세요.
  2. REQUIRES_NEW를 지워 테스트가 통과하는지 확인하고 복원하세요.
  3. 적립 리스너가 예외를 던지면 주문 상태가 어떻게 될지 예측해 보세요(이 Chapter에서는 테스트하지 않았습니다. 커밋 이후라 주문만 남는다고 추정합니다).

이벤트·트랜잭션 오류

이벤트 기반 코드는 실행되지 않아도 오류가 나지 않는 것이 가장 큰 함정입니다. 아래는 이 예제를 한 군데씩 바꿔 얻은 결과입니다. 바꾼 코드는 되돌렸고 저장소에는 올리지 않았습니다.

1. 적립금이 쌓이지 않는다: 트랜잭션이 없으면 리스너가 안 돈다

OrderService.place에서 @Transactional을 지웠습니다. 주문은 저장되고 응답도 정상인데 적립금만 0입니다. 17건 중 2건이 실패했습니다.

orderEarnsOnePercentRewardThroughEventWithoutOrderKnowingReward()
AssertionFailedError: expected: <300> but was: <0>
rewardsAccumulatePerMember()
expected: <180> but was: <0>

@TransactionalEventListener(AFTER_COMMIT)는 트랜잭션이 커밋될 때 실행됩니다. 트랜잭션이 없으면 커밋도 없으므로 리스너가 조용히 건너뛰어집니다. 예외도 로그도 없습니다. 이벤트를 발행했는데 반응이 없다면 발행하는 쪽에 트랜잭션이 걸려 있는지 먼저 봅니다.

2. 롤백됐는데 적립금이 남는다: 일반 리스너로 바꾸면

반대로 리스너를 @TransactionalEventListener가 아니라 일반 @EventListener로 바꾸면, 주문 트랜잭션 도중에 바로 실행됩니다. 17건 중 3건이 실패했습니다.

rolledBackTransactionNeverReachesTheListener()
AssertionFailedError: expected: <0> but was: <500>
orderJoinsOuterTransactionSoRollbackRemovesOrderAndSkipsReward()
expected: <0> but was: <150>
eventListenerRunsOnlyAfterCommit()
expected: <0> but was: <100>

주문이 롤백되어 없어졌는데 적립금은 별도 트랜잭션(REQUIRES_NEW)으로 이미 커밋되어 주문 없는 적립금이 생겼습니다. “롤백되면 적립하지 않는다”는 약속이 깨진 것이고, 이 모양은 돈과 포인트가 어긋나는 가장 흔한 원인입니다.

증상 가장 먼저 볼 것
이벤트를 발행했는데 반응이 없음(오류 없음) 발행하는 쪽의 @Transactional
롤백된 주문의 부수 효과가 남음 리스너가 AFTER_COMMIT인지 일반 @EventListener인지
리스너 안에서 DB 변경이 반영되지 않음 리스너의 트랜잭션 전파(REQUIRES_NEW)

이 표의 마지막 행은 문서의 안내에 근거한 점검 항목이고, 이 예제에서 재현하지는 못했습니다(앞의 “REQUIRES_NEW를 붙인 이유와 확인하지 못한 점” 절).

지금의 한계

적립 리스너 실패 시 주문 상태, 같은 회원의 동시 주문 적립 경합, 모듈별 테이블 소유를 검사하는 테스트는 없습니다. 이벤트 유실이나 재시도(아웃박스 패턴 등)는 다루지 않았습니다.

직접 해 보기

  1. 1번 실험을 직접 재현하고 로그에 오류가 없는 것을 눈으로 확인하세요(복원).
  2. 이벤트가 유실될 수 있는 상황을 두 가지 떠올려 보세요.
  3. 일반 @EventListener가 어울리는 경우가 있다면 언제인지 생각해 보세요.

계약 정리: 한눈에 보는 계약 지도

Chapter 12에서 “계약은 서로 다른 쪽이 따로 바뀌어도 함께 동작하게 하는 약속”이라고 했습니다. 그 뒤 이 과정의 코드에서 계약은 여섯 가지 모양으로 나타났습니다. 이 절은 여섯 계약을 한 표로 놓고, 어떤 상황에 무엇을 쓰는지 정리합니다. 새 코드는 없고 이미 본 코드의 위치를 이어 주는 절입니다.

공통 질문

모든 계약은 같은 질문에 답합니다. “이쪽이 약속하는 것은 무엇이고, 저쪽은 무엇을 몰라도 되는가?”

여섯 계약 한눈에

계약 누가 소유 코드 약속하는 것 몰라도 되는 것 지키는 장치
외부 API 계약 서버(소비자는 클라이언트) contract 패키지의 UserView, ErrorBody, /api/v1 (Chapter 12) 요청·응답 모양, 오류 코드 내부 엔티티, 저장 방식 OpenAPI 스냅샷 비교, ArchUnit
응용이 바라는 계약(Port) 응용 계층 AddressLookupPort (Chapter 15) 도메인 타입 반환, 없음=Optional, 장애=약속된 예외 외부 API의 HTTP·필드 이름 진짜 HTTP 어댑터 테스트, ArchUnit
규칙 계약 정책 도메인 DiscountRule.discount() (앞의 “계약으로서 본 DiscountRule” 절) 주문 정보 → 깎을 금액 규칙 개수, 합산/선택 Composite 계산 테스트
협력 서비스 계약 각 서비스 PaymentService.charge/refund, InventoryService (앞의 “서비스 계약: 정상, 실패, 보상” 절) 정상·실패·보상 구현, 다른 서비스 호출 기록 가짜로 순서 검사
모듈 공개 계약 각 모듈 member.api, order.api (앞의 “네 모듈” 절) 공개 인터페이스와 값 internal 구현 컴파일러(패키지 전용), ArchUnit
이벤트 계약 발행 모듈 OrderPlaced (앞의 “이벤트 계약” 절) 사실의 모양, 커밋 이후 전달 누가 듣는지, 처리 방법 커밋 전후 테스트

상황별로 고르기

상황 쓸 계약
외부 클라이언트(웹, 앱)에 API를 공개 외부 API 계약 + 버전(/api/v1)
외부 업체 API를 호출해야 함 Port + 어댑터 번역, 실패를 약속된 예외로
정책이 자주 바뀌고 조합됨 규칙 계약(Composite)
여러 서비스를 순서대로 부르고 되돌려야 함 협력 서비스 계약 + Orchestrator
같은 앱 안 업무 영역 사이의 호출 모듈 공개 계약(api)
한 업무의 사건에 다른 업무가 반응해야 함 이벤트 계약(커밋 이후)

계약을 지키는 세 가지 장치

장치 지키는 것 예
컴파일러 가시성(패키지 전용) internal의 클래스는 다른 모듈이 import 불가
구조 테스트(ArchUnit) 의존 방향, 순환, 가시성 Chapter 12, 15, 16
동작 테스트 정상·실패·보상·시점 스냅샷, 진짜 HTTP, 호출 기록 가짜, 커밋 전후

이어지는 Chapter

Chapter 17에서는 모듈 호출 계약 위에서 값 목록을 한 번에 넘기는 호출(가변 IN)과 코드로 정의한 호출 규칙을 다룹니다. 이는 일곱 번째 계약(모듈 호출 계약)의 모양입니다.

직접 해 보기

  1. 자신의 프로젝트에서 위 여섯 계약 중 이미 있는 것과 없는 것을 체크해 보세요.
  2. 가장 변경이 잦은 경계 하나를 골라 어떤 계약과 어떤 지키는 장치가 필요한지 적어 보세요.
  3. 계약이 너무 많아지는 것(과설계)을 막는 기준을 한 줄로 적어 보세요.

자주 하는 실수 점검표

증상이 보이면 같은 행의 원인부터 확인합니다.

영역 증상 원인 해결
Composite 합산이 줄어듦 해당하지 않는 규칙이 0 대신 음수를 돌려줌 해당 없으면 0
Composite 결제 금액이 음수 합산 결과를 주문 금액으로 제한하지 않음 Math.min(total, amount)
Composite 규칙 재사용이 어려움 묶음 방식(합산/최대)을 규칙 안에서 정함 묶음은 Composite가 정함
정책 조립 할인이 의도보다 큼 bestOf를 sumOf로 착각 계산표로 기대값을 먼저 확인
정책 조립 할인이 금액보다 커짐 경계 사례(작은 금액)를 테스트하지 않음 상한 처리 테스트
정책 조립 정책 파악이 어려움 조립을 여러 곳에서 함 @Bean 한 곳에서 조립
Orchestration 되돌리기 중 일관성이 깨질 수 있음 보상 순서가 일어난 순서와 같음 일어난 순서의 반대
Orchestration 흐름이 흩어짐 서비스끼리 서로를 호출 흐름은 Orchestrator 한 곳
Orchestration 상태 코드를 나눌 수 없음 예외를 단계 정보 없이 던짐 OrderFailedException("단계", 원인)
보상 테스트 보상 누락을 놓침(402는 정상) 상태 코드만 검사 호출 기록과 남은 재고 검사
보상 테스트 실패 경로의 버그가 배포 후 드러남 성공 경로만 테스트 단계별 실패 시나리오
보상 테스트 순서 오류를 놓침 호출 순서를 contains로만 검사 목록 전체를 순서까지 비교
전략 해당 방법이 목록에 없음 전략 구현체에 @Component를 빠뜨림 @Component 등록 확인
전략 앱 기동 실패 두 구현체의 key()가 같음 key() 유일하게
전략 전략 패턴의 이점 상실 선택하는 쪽에 if/else가 다시 생김 맵에서 이름으로 선택
전략 Bean 기동 시 예외 Map.of/toMap에서 중복 key toUnmodifiableMap으로 즉시 실패
전략 Bean 응답이 실행마다 다름 방법 목록의 순서가 일정하지 않음 정렬해서 반환
전략 Bean 느림 테스트에서 Spring을 항상 사용 List.of(...)로 직접 조립
도구 선택 클래스만 늘고 읽기 어려움 분기가 두 개인데 전략으로 분리 안정적이면 if 유지
도구 선택 중간 실패 처리 불가 순서·보상이 필요한데 전략으로 풀려 함 Orchestration
도구 선택 메서드가 거대해짐 합산 규칙이 복잡한데 if로 계속 확장 Composite 고려
모듈 경계 다른 모듈이 import 가능해짐 internal 클래스를 public으로 선언 패키지 전용 + ArchUnit
모듈 경계 모듈이 서로 묶임 api에 구현 세부(테이블 구조 등)를 노출 필요한 질문만 공개
모듈 경계 경계가 무너짐 다른 모듈의 구현 클래스를 직접 주입 api 인터페이스만 주입
순환 참조 member와 order의 양방향 의존 순환 회원 모듈에서 주문 이벤트를 직접 듣게 함 적립을 별도 모듈로
순환 참조 가시성 위반을 놓침 beFreeOfCycles 규칙만 믿음 가시성·허용 의존 규칙 병행
순환 참조 기본값에서는 failed to check any classes로 실패, 빈 검사를 허용했다면 조용히 통과(Chapter 12) 규칙 대상 패키지 이름 오타 모듈별 클래스 존재 검사
이벤트 롤백된 주문의 적립이 남음 일반 @EventListener를 사용 @TransactionalEventListener(AFTER_COMMIT)
이벤트 리스너가 조용히 실행되지 않음 발행하는 쪽에 @Transactional이 없음 트랜잭션 안에서 발행
이벤트 다른 모듈이 못 씀 이벤트 타입을 internal에 둠 api 패키지에 둠

용어와 참고 자료

이 절은 Chapter 16 전체에서 나온 용어와 참고한 사이트를 모았습니다. 계약과 Port의 기본 용어는 Chapter 12 용어 정리, Chapter 15 용어 정리를 참고하세요.

패턴

용어 설명
Composite 단일 객체와 묶음을 같은 인터페이스로 다루는 패턴입니다.
합산 / 최대값 선택 이 예제의 두 가지 묶음 방식입니다(sumOf, bestOf).
Strategy(전략) 방법별 규칙을 구현 클래스로 나누고 선택하는 쪽은 고르기만 하는 패턴입니다.
Orchestration 여러 서비스를 한 곳에서 순서대로 부르고 실패를 처리하는 방식입니다.
보상(compensation) 앞서 한 일을 되돌리는 동작입니다. refund, release가 그 예입니다.
호출 기록 가짜(recording fake) 호출 이름을 리스트에 남겨 순서를 검사하는 테스트용 구현입니다.
컴팩트 생성자 record 생성자에서 값 검증을 하는 문법입니다.

모듈과 이벤트

용어 설명
모듈러 모놀리스 배포는 하나이면서 코드는 모듈로 나누고 경계를 지키는 구조입니다.
api / internal 모듈의 공개 계약 패키지와 비공개 구현 패키지입니다.
순환 참조 A가 B를, B가 A를 알아서 따로 바꿀 수 없는 상태입니다.
슬라이스(slice) ArchUnit에서 패키지 일부로 나눈 검사 단위입니다.
이벤트 일어난 사실을 알리는 객체입니다. 발행자는 듣는 쪽을 모릅니다.
@TransactionalEventListener 트랜잭션 단계(커밋 이후 등)에 맞춰 호출되는 이벤트 리스너입니다.
REQUIRES_NEW 새 트랜잭션을 시작하는 전파 방식입니다.

참고 자료

직접 해보기

  1. ch25, ch34, ch26 예제의 테스트를 실행해 15건, 12건, 17건이 통과하는지 확인하세요.
  2. Orchestrator의 보상 호출 하나를 지우고 어떤 테스트가 어떤 호출 기록으로 실패하는지 읽은 뒤 되돌리세요.
  3. 자신의 프로젝트에서 if가 쌓인 메서드 하나를 골라 Composite, 전략, Orchestration 중 무엇이 맞는지, 아니면 if로 두는 편이 나은지 근거와 함께 적어 보세요.

이번 장의 정리

이 Chapter에서는 if가 쌓이는 주문 코드를 세 가지 도구와 모듈 경계로 정리했습니다.

  • Composite는 규칙 하나와 규칙 묶음을 같은 DiscountRule로 다루고, 정책은 @Bean 한 곳에서 sumOf/bestOf 트리로 조립하며, 계산 예를 테스트로 고정합니다.
  • Orchestrator는 재고, 결제, 배송의 순서와 보상을 한 클래스에 모으고, 보상은 일어난 순서의 반대로 실행합니다.
  • 보상은 실패 경로에서만 실행되므로 호출 기록 가짜로 호출 순서 전체를 비교하고 남은 재고까지 검사합니다.
  • 전략 패턴은 방법마다 구현 클래스를 두고, 계산기는 List 주입으로 모은 전략을 key()로 고르며, 중복 key는 기동 시점에 막습니다.
  • Composite는 조합, 전략은 선택, Orchestration은 순서와 보상에 쓰고, 변하지 않는 두세 개의 분기는 그냥 if로 둡니다.
  • 모듈은 api와 internal로 나누고, 패키지 전용 가시성과 ArchUnit 규칙으로 순환과 경계 침범을 막습니다.
  • 모듈 사이의 사실은 OrderPlaced 이벤트로 알리고, AFTER_COMMIT 리스너로 커밋된 뒤에만 적립합니다.
  • 발행하는 쪽에 트랜잭션이 없으면 리스너가 오류 없이 실행되지 않고, 일반 @EventListener는 롤백된 주문의 적립을 남깁니다.
  • 외부 API, Port, 규칙, 협력 서비스, 모듈 공개, 이벤트의 여섯 계약은 모두 “무엇을 약속하고 무엇을 몰라도 되는가”에 답하며, 컴파일러·구조 테스트·동작 테스트로 지킵니다.

예제 저장소에서 코드를 직접 실행하고 조건과 실패 상황을 바꾸어 보면 각 선택이 필요한 이유를 더 분명하게 이해할 수 있습니다.

다음 Chapter 17 모듈 호출 오케스트레이션에서는 모듈 호출 계약 위에서 값 목록을 한 번에 넘기는 호출과 코드로 정의한 호출 규칙을 다룹니다.

FAQ

자주 묻는 질문

Composite는 언제 쓰는 것이 좋은가요?

같은 계약을 따르는 규칙을 합산하거나 최댓값 선택처럼 재귀적으로 조합할 때 적합합니다. 규칙이 몇 개뿐이면 단순 코드가 더 읽기 쉬울 수 있습니다.

보상 처리는 데이터베이스 롤백과 같은가요?

아닙니다. 이미 외부 결제나 배송 요청이 끝났다면 로컬 트랜잭션 롤백만으로 되돌릴 수 없어 환불이나 재고 반환 같은 별도 동작이 필요합니다.

Strategy Bean이 여러 개일 때 어떻게 선택하나요?

예제는 각 전략이 지원하는 방법을 공개하고 계산기가 Map으로 구성해 키로 찾습니다. 중복 키와 없는 키도 명시적으로 검사합니다.

이벤트 리스너를 커밋 이후에 실행하는 이유는 무엇인가요?

주문 트랜잭션이 롤백됐는데 적립 같은 후속 작업만 남는 상황을 막기 위해서입니다.

작성·편집 ToolPado

콘텐츠 유형 Spring Boot 학습 가이드

기술 기준 Spring Boot 4.1.1 · JDK 21

마지막 검토