Spring 01: 디자인 패턴 (1)

Spring에서 사용되는 주요 디자인 패턴

❌ 패턴 없는 코드 (안티패턴)

public class OrderService {
    
    public Money calculateDiscount(Order order, String discountType) {
        Money discount = Money.ZERO;
        
        if (discountType.equals("PERCENT")) {
            // 퍼센트 할인
            discount = order.getTotalPrice().multiply(0.1);
        } else if (discountType.equals("FIXED")) {
            // 정액 할인
            discount = Money.of(10000);
        } else if (discountType.equals("BULK")) {
            // 대량 구매 할인
            if (order.getItemCount() >= 10) {
                discount = order.getTotalPrice().multiply(0.15);
            }
        } else if (discountType.equals("VIP")) {
            // VIP 할인
            if (order.getCustomer().isVip()) {
                discount = order.getTotalPrice().multiply(0.2);
            }
        } else if (discountType.equals("SEASONAL")) {
            // 시즌 할인
            if (isHolidaySeason()) {
                discount = order.getTotalPrice().multiply(0.25);
            }
        }
        // 새로운 할인 정책이 추가될 때마다 else if 추가...
        
        return discount;
    }
}

✅ Strategy 패턴 적용 코드

// 1. 전략 인터페이스 정의
public interface DiscountPolicy {
    Money calculateDiscount(Order order);
    boolean supports(Order order);
}

// 2. 구체적인 전략 구현
@Component
public class PercentDiscountPolicy implements DiscountPolicy {
    @Override
    public Money calculateDiscount(Order order) {
        return order.getTotalPrice().multiply(0.1);
    }
    
    @Override
    public boolean supports(Order order) {
        return order.hasPercentCoupon();
    }
}

@Component
public class VipDiscountPolicy implements DiscountPolicy {
    @Override
    public Money calculateDiscount(Order order) {
        return order.getTotalPrice().multiply(0.2);
    }
    
    @Override
    public boolean supports(Order order) {
        return order.getCustomer().isVip();
    }
}

// 3. 서비스에서 전략 사용 (Spring DI 활용)
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final List<DiscountPolicy> discountPolicies; // 모든 정책 자동 주입
    
    public Money calculateDiscount(Order order) {
        return discountPolicies.stream()
            .filter(policy -> policy.supports(order))
            .map(policy -> policy.calculateDiscount(order))
            .reduce(Money.ZERO, Money::add);
    }
}

방법 1: Eager Initialization (즉시 초기화)

public class ProductCacheManager {
    
    // 클래스 로딩 시점에 인스턴스 생성
    private static final ProductCacheManager INSTANCE = new ProductCacheManager();
    
    private final Map<Long, Product> cache = new ConcurrentHashMap<>();
    
    // private 생성자 - 외부에서 new 불가
    private ProductCacheManager() {
        System.out.println("ProductCacheManager 인스턴스 생성");
    }
    
    // 전역 접근점
    public static ProductCacheManager getInstance() {
        return INSTANCE;
    }
    
    public void put(Long productId, Product product) {
        cache.put(productId, product);
    }
    
    public Optional<Product> get(Long productId) {
        return Optional.ofNullable(cache.get(productId));
    }
    
    public void evict(Long productId) {
        cache.remove(productId);
    }
}

// 사용
ProductCacheManager cache = ProductCacheManager.getInstance();
cache.put(1L, product);

방법 2: Lazy Initialization with Double-Checked Locking

public class ProductCacheManager {
    
    // volatile: 멀티스레드 환경에서 가시성 보장
    private static volatile ProductCacheManager instance;
    
    private final Map<Long, Product> cache = new ConcurrentHashMap<>();
    
    private ProductCacheManager() {}
    
    public static ProductCacheManager getInstance() {
        if (instance == null) {                    // 1차 체크 (성능)
            synchronized (ProductCacheManager.class) {
                if (instance == null) {            // 2차 체크 (안전성)
                    instance = new ProductCacheManager();
                }
            }
        }
        return instance;
    }
}

방법 3: Bill Pugh Singleton (권장)

public class ProductCacheManager {
    
    private final Map<Long, Product> cache = new ConcurrentHashMap<>();
    
    private ProductCacheManager() {}
    
    // static inner class - 클래스 로딩 시점에 초기화
    private static class Holder {
        private static final ProductCacheManager INSTANCE = new ProductCacheManager();
    }
    
    public static ProductCacheManager getInstance() {
        return Holder.INSTANCE;  // Holder 클래스가 로딩될 때 인스턴스 생성
    }
}

✅ Spring 방식 (권장)

@Component  // Spring이 Singleton으로 관리
public class ProductCacheManager {
    
    private final Map<Long, Product> cache = new ConcurrentHashMap<>();
    
    // public 생성자 OK - Spring이 한 번만 호출
    public ProductCacheManager() {
        System.out.println("ProductCacheManager 인스턴스 생성");
    }
    
    public void put(Long productId, Product product) {
        cache.put(productId, product);
    }
    
    public Optional<Product> get(Long productId) {
        return Optional.ofNullable(cache.get(productId));
    }
}

// 사용 - DI로 주입받음
@Service
@RequiredArgsConstructor
public class ProductService {
    
    private final ProductCacheManager cacheManager;  // 자동 주입
    
    public Product getProduct(Long id) {
        return cacheManager.get(id)
            .orElseGet(() -> loadFromDatabase(id));
    }
}

❌ 잘못된 예 - 상태를 가진 Singleton

@Service
public class OrderService {
    
    // ❌ 위험! 인스턴스 변수로 상태 저장
    private Order currentOrder;
    private Customer currentCustomer;
    
    public void createOrder(Customer customer) {
        this.currentCustomer = customer;  // Thread A가 설정
        this.currentOrder = new Order();
        // ... 처리 중 Thread B가 currentCustomer를 덮어씀!
        this.currentOrder.setCustomer(this.currentCustomer);  // 잘못된 고객!
    }
}

✅ 올바른 예 - Stateless Singleton

@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final OrderRepository orderRepository;  // ✅ 의존성만 가짐
    private final PaymentService paymentService;
    
    // 모든 상태는 메서드 파라미터와 지역 변수로 처리
    public Order createOrder(Customer customer, List<OrderItem> items) {
        Order order = new Order();  // ✅ 지역 변수
        order.setCustomer(customer);
        order.setItems(items);
        order.calculateTotal();
        
        return orderRepository.save(order);
    }
}

Spring + Caffeine 캐시를 활용한 상품 캐시

@Component
public class ProductCache {
    
    // Caffeine 캐시 - Thread-safe한 상태 저장 가능
    private final Cache<Long, Product> cache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(Duration.ofMinutes(10))
        .recordStats()
        .build();
    
    public Optional<Product> get(Long productId) {
        return Optional.ofNullable(cache.getIfPresent(productId));
    }
    
    public void put(Long productId, Product product) {
        cache.put(productId, product);
    }
    
    public void evict(Long productId) {
        cache.invalidate(productId);
    }
    
    public CacheStats getStats() {
        return cache.stats();
    }
}

@Service
@RequiredArgsConstructor
public class ProductService {
    
    private final ProductCache productCache;      // Singleton
    private final ProductRepository productRepository;
    
    public Product getProduct(Long productId) {
        // 1. 캐시 조회
        return productCache.get(productId)
            .orElseGet(() -> {
                // 2. DB 조회
                Product product = productRepository.findById(productId)
                    .orElseThrow(() -> new ProductNotFoundException(productId));
                // 3. 캐시 저장
                productCache.put(productId, product);
                return product;
            });
    }
    
    @Transactional
    public Product updateProduct(Long productId, ProductUpdateRequest request) {
        Product product = productRepository.findById(productId)
            .orElseThrow(() -> new ProductNotFoundException(productId));
        
        product.update(request);
        
        // 캐시 무효화
        productCache.evict(productId);
        
        return productRepository.save(product);
    }
}

Factory 패턴의 종류

❌ Factory 없이 구현 (안티패턴)

@Service
public class DiscountService {
    
    public DiscountPolicy getDiscountPolicy(String type, Map<String, Object> params) {
        // 조건문 지옥
        if ("PERCENT".equals(type)) {
            double rate = (Double) params.get("rate");
            return new PercentDiscountPolicy(rate);
        } else if ("FIXED".equals(type)) {
            Money amount = (Money) params.get("amount");
            return new FixedDiscountPolicy(amount);
        } else if ("BULK".equals(type)) {
            int minQuantity = (Integer) params.get("minQuantity");
            double rate = (Double) params.get("rate");
            return new BulkDiscountPolicy(minQuantity, rate);
        } else if ("VIP".equals(type)) {
            return new VipDiscountPolicy();
        } else if ("SEASONAL".equals(type)) {
            LocalDate startDate = (LocalDate) params.get("startDate");
            LocalDate endDate = (LocalDate) params.get("endDate");
            double rate = (Double) params.get("rate");
            return new SeasonalDiscountPolicy(startDate, endDate, rate);
        }
        // 새로운 할인 정책 추가 시 여기를 수정해야 함...
        
        throw new IllegalArgumentException("Unknown discount type: " + type);
    }
}

✅ Factory 패턴 적용

// 1. 할인 정책 인터페이스
public interface DiscountPolicy {
    Money calculateDiscount(Order order);
    DiscountType getType();
}

// 2. 구체적인 할인 정책들
public class PercentDiscountPolicy implements DiscountPolicy {
    private final double rate;
    
    public PercentDiscountPolicy(double rate) {
        this.rate = rate;
    }
    
    @Override
    public Money calculateDiscount(Order order) {
        return order.getTotalPrice().multiply(rate);
    }
    
    @Override
    public DiscountType getType() {
        return DiscountType.PERCENT;
    }
}

public class FixedDiscountPolicy implements DiscountPolicy {
    private final Money amount;
    
    public FixedDiscountPolicy(Money amount) {
        this.amount = amount;
    }
    
    @Override
    public Money calculateDiscount(Order order) {
        return amount;
    }
    
    @Override
    public DiscountType getType() {
        return DiscountType.FIXED;
    }
}

// 3. Factory 인터페이스
public interface DiscountPolicyFactory {
    DiscountPolicy create(DiscountCondition condition);
    DiscountType getSupportedType();
}

// 4. 구체적인 Factory들
@Component
public class PercentDiscountPolicyFactory implements DiscountPolicyFactory {
    
    @Override
    public DiscountPolicy create(DiscountCondition condition) {
        return new PercentDiscountPolicy(condition.getRate());
    }
    
    @Override
    public DiscountType getSupportedType() {
        return DiscountType.PERCENT;
    }
}

@Component
public class FixedDiscountPolicyFactory implements DiscountPolicyFactory {
    
    @Override
    public DiscountPolicy create(DiscountCondition condition) {
        return new FixedDiscountPolicy(condition.getAmount());
    }
    
    @Override
    public DiscountType getSupportedType() {
        return DiscountType.FIXED;
    }
}

5. Factory Registry (Spring DI 활용)

@Component
public class DiscountPolicyFactoryRegistry {
    
    private final Map<DiscountType, DiscountPolicyFactory> factories;
    
    // Spring이 모든 DiscountPolicyFactory 구현체를 자동 주입
    public DiscountPolicyFactoryRegistry(List<DiscountPolicyFactory> factoryList) {
        this.factories = factoryList.stream()
            .collect(Collectors.toMap(
                DiscountPolicyFactory::getSupportedType,
                Function.identity()
            ));
    }
    
    public DiscountPolicy create(DiscountType type, DiscountCondition condition) {
        DiscountPolicyFactory factory = factories.get(type);
        if (factory == null) {
            throw new IllegalArgumentException("No factory for type: " + type);
        }
        return factory.create(condition);
    }
}

// 사용
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final DiscountPolicyFactoryRegistry factoryRegistry;
    
    public Order applyDiscount(Order order, Coupon coupon) {
        DiscountPolicy policy = factoryRegistry.create(
            coupon.getDiscountType(),
            coupon.getCondition()
        );
        
        Money discount = policy.calculateDiscount(order);
        order.applyDiscount(discount);
        
        return order;
    }
}

Spring의 Factory 패턴 적용 사례

@Bean 메서드 = Factory Method

@Configuration
public class PaymentConfig {
    
    // @Bean 메서드는 Factory Method 패턴
    @Bean
    public PaymentGateway paymentGateway(PaymentProperties properties) {
        // 복잡한 생성 로직을 캡슐화
        PaymentGateway gateway = new PaymentGateway();
        gateway.setApiKey(properties.getApiKey());
        gateway.setSecretKey(properties.getSecretKey());
        gateway.setEnvironment(properties.getEnvironment());
        gateway.setTimeout(properties.getTimeout());
        gateway.setRetryCount(properties.getRetryCount());
        gateway.initialize();  // 초기화 로직
        return gateway;
    }
    
    @Bean
    @Profile("production")
    public PaymentProcessor realPaymentProcessor(PaymentGateway gateway) {
        return new RealPaymentProcessor(gateway);
    }
    
    @Bean
    @Profile("!production")
    public PaymentProcessor mockPaymentProcessor() {
        return new MockPaymentProcessor();  // 테스트용
    }
}

FactoryBean 인터페이스

// 복잡한 객체 생성을 위한 FactoryBean
@Component
public class ShippingCalculatorFactoryBean implements FactoryBean<ShippingCalculator> {
    
    @Value("${shipping.provider}")
    private String provider;
    
    @Autowired
    private ShippingProperties properties;
    
    @Override
    public ShippingCalculator getObject() throws Exception {
        // 복잡한 생성 로직
        ShippingCalculator calculator = switch (provider) {
            case "DHL" -> new DhlShippingCalculator(properties.getDhlConfig());
            case "FEDEX" -> new FedexShippingCalculator(properties.getFedexConfig());
            case "UPS" -> new UpsShippingCalculator(properties.getUpsConfig());
            default -> new DefaultShippingCalculator();
        };
        
        calculator.initialize();
        return calculator;
    }
    
    @Override
    public Class<?> getObjectType() {
        return ShippingCalculator.class;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
}

// 사용 - ShippingCalculator로 주입받음 (FactoryBean이 아님!)
@Service
@RequiredArgsConstructor
public class ShippingService {
    private final ShippingCalculator shippingCalculator;
}

❌ Template Method 없이 구현

@Service
public class CreditCardOrderService {
    
    public Order processOrder(OrderRequest request) {
        // 1. 주문 검증 (공통)
        validateOrder(request);
        
        // 2. 재고 확인 (공통)
        checkInventory(request.getItems());
        
        // 3. 결제 처리 (신용카드 전용)
        CreditCardPayment payment = processCreditCardPayment(request);
        
        // 4. 주문 생성 (공통)
        Order order = createOrder(request, payment);
        
        // 5. 재고 차감 (공통)
        decreaseInventory(request.getItems());
        
        // 6. 알림 발송 (공통)
        sendNotification(order);
        
        return order;
    }
}

@Service
public class KakaoPayOrderService {
    
    public Order processOrder(OrderRequest request) {
        // 1. 주문 검증 (공통) - 중복!
        validateOrder(request);
        
        // 2. 재고 확인 (공통) - 중복!
        checkInventory(request.getItems());
        
        // 3. 결제 처리 (카카오페이 전용)
        KakaoPayment payment = processKakaoPayment(request);
        
        // 4. 주문 생성 (공통) - 중복!
        Order order = createOrder(request, payment);
        
        // ... 나머지도 중복
    }
}

// 결제 방식마다 서비스 클래스가 늘어나고, 공통 로직이 중복됨

✅ Template Method 패턴 적용

// 1. 추상 템플릿 클래스
public abstract class OrderProcessTemplate {
    
    // 템플릿 메서드 - 알고리즘 골격 정의
    public final Order processOrder(OrderRequest request) {
        // 1. 주문 검증 (공통)
        validateOrder(request);
        
        // 2. 재고 확인 (공통)
        checkInventory(request.getItems());
        
        // 3. 결제 처리 (서브클래스 구현)
        Payment payment = processPayment(request);
        
        // 4. 주문 생성 (공통)
        Order order = createOrder(request, payment);
        
        // 5. 재고 차감 (공통)
        decreaseInventory(request.getItems());
        
        // 6. 후처리 Hook (선택적 확장)
        afterOrderCreated(order);
        
        // 7. 알림 발송 (공통)
        sendNotification(order);
        
        return order;
    }
    
    // 공통 구현
    private void validateOrder(OrderRequest request) {
        if (request.getItems().isEmpty()) {
            throw new InvalidOrderException("주문 항목이 비어있습니다");
        }
        // 기타 검증 로직...
    }
    
    private void checkInventory(List<OrderItem> items) {
        for (OrderItem item : items) {
            if (!inventoryService.hasStock(item.getProductId(), item.getQuantity())) {
                throw new OutOfStockException(item.getProductId());
            }
        }
    }
    
    private Order createOrder(OrderRequest request, Payment payment) {
        Order order = Order.create(request, payment);
        return orderRepository.save(order);
    }
    
    private void decreaseInventory(List<OrderItem> items) {
        items.forEach(item -> 
            inventoryService.decrease(item.getProductId(), item.getQuantity())
        );
    }
    
    private void sendNotification(Order order) {
        notificationService.sendOrderConfirmation(order);
    }
    
    // 추상 메서드 - 서브클래스가 반드시 구현
    protected abstract Payment processPayment(OrderRequest request);
    
    // Hook 메서드 - 선택적 오버라이드
    protected void afterOrderCreated(Order order) {
        // 기본 구현은 비어있음
    }
}

2. 구체적인 구현 클래스들

@Component
public class CreditCardOrderProcessor extends OrderProcessTemplate {
    
    private final CreditCardGateway creditCardGateway;
    
    @Override
    protected Payment processPayment(OrderRequest request) {
        CreditCardInfo cardInfo = request.getCreditCardInfo();
        
        // 신용카드 결제 처리
        PaymentResult result = creditCardGateway.charge(
            cardInfo.getCardNumber(),
            cardInfo.getExpiry(),
            cardInfo.getCvv(),
            request.getTotalAmount()
        );
        
        return Payment.creditCard(result.getTransactionId(), request.getTotalAmount());
    }
}

@Component
public class KakaoPayOrderProcessor extends OrderProcessTemplate {
    
    private final KakaoPayClient kakaoPayClient;
    
    @Override
    protected Payment processPayment(OrderRequest request) {
        // 카카오페이 결제 처리
        KakaoPayResponse response = kakaoPayClient.requestPayment(
            request.getOrderId(),
            request.getTotalAmount()
        );
        
        return Payment.kakaoPay(response.getTid(), request.getTotalAmount());
    }
    
    @Override
    protected void afterOrderCreated(Order order) {
        // 카카오페이 전용 후처리 - 포인트 적립
        kakaoPayClient.earnPoints(order.getCustomerId(), order.getTotalAmount());
    }
}

@Component
public class NaverPayOrderProcessor extends OrderProcessTemplate {
    
    private final NaverPayClient naverPayClient;
    
    @Override
    protected Payment processPayment(OrderRequest request) {
        // 네이버페이 결제 처리
        NaverPayResponse response = naverPayClient.pay(
            request.getOrderId(),
            request.getTotalAmount()
        );
        
        return Payment.naverPay(response.getPaymentId(), request.getTotalAmount());
    }
}

JdbcTemplate - JDBC 반복 코드 제거

// JdbcTemplate 없이 (반복 코드 지옥)
public List<Product> findAllProducts() {
    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    List<Product> products = new ArrayList<>();
    
    try {
        conn = dataSource.getConnection();           // 1. 커넥션 획득
        pstmt = conn.prepareStatement(               // 2. SQL 준비
            "SELECT * FROM products WHERE active = ?"
        );
        pstmt.setBoolean(1, true);                   // 3. 파라미터 바인딩
        rs = pstmt.executeQuery();                   // 4. 쿼리 실행
        
        while (rs.next()) {                          // 5. 결과 매핑
            products.add(new Product(
                rs.getLong("id"),
                rs.getString("name"),
                rs.getBigDecimal("price")
            ));
        }
    } catch (SQLException e) {
        throw new DataAccessException(e);            // 6. 예외 변환
    } finally {
        if (rs != null) try { rs.close(); } catch (SQLException e) {}
        if (pstmt != null) try { pstmt.close(); } catch (SQLException e) {}
        if (conn != null) try { conn.close(); } catch (SQLException e) {}
    }                                                // 7. 리소스 정리
    
    return products;
}

// JdbcTemplate 사용 (Template Method 패턴)
public List<Product> findAllProducts() {
    return jdbcTemplate.query(
        "SELECT * FROM products WHERE active = ?",
        (rs, rowNum) -> new Product(                 // 변하는 부분만 구현
            rs.getLong("id"),
            rs.getString("name"),
            rs.getBigDecimal("price")
        ),
        true
    );
}

Spring의 다양한 Template 클래스들

TransactionTemplate 예제

@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final TransactionTemplate transactionTemplate;
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    
    public Order createOrder(OrderRequest request) {
        // TransactionTemplate이 트랜잭션 시작/커밋/롤백을 처리
        return transactionTemplate.execute(status -> {
            // 개발자는 비즈니스 로직만 구현
            Order order = Order.create(request);
            orderRepository.save(order);
            
            for (OrderItem item : order.getItems()) {
                inventoryService.decrease(item.getProductId(), item.getQuantity());
            }
            
            return order;
        });
    }
}

❌ Strategy 없이 구현 (조건문 지옥)

@Service
public class PaymentService {
    
    public PaymentResult processPayment(Order order, String paymentMethod) {
        
        if ("CREDIT_CARD".equals(paymentMethod)) {
            // 신용카드 결제 로직
            CreditCardInfo cardInfo = order.getCreditCardInfo();
            return creditCardGateway.charge(cardInfo, order.getTotalAmount());
            
        } else if ("KAKAO_PAY".equals(paymentMethod)) {
            // 카카오페이 결제 로직
            return kakaoPayClient.requestPayment(order.getId(), order.getTotalAmount());
            
        } else if ("NAVER_PAY".equals(paymentMethod)) {
            // 네이버페이 결제 로직
            return naverPayClient.pay(order.getId(), order.getTotalAmount());
            
        } else if ("TOSS_PAY".equals(paymentMethod)) {
            // 토스페이 결제 로직
            return tossPayClient.execute(order.getId(), order.getTotalAmount());
            
        } else if ("BANK_TRANSFER".equals(paymentMethod)) {
            // 무통장입금 로직
            return bankTransferService.createVirtualAccount(order);
            
        }
        // 새로운 결제 수단 추가 시 여기를 수정해야 함...
        
        throw new UnsupportedPaymentMethodException(paymentMethod);
    }
}

✅ Strategy 패턴 적용

// 1. Strategy 인터페이스
public interface PaymentStrategy {
    PaymentResult pay(Order order);
    PaymentMethod getPaymentMethod();
    boolean supports(PaymentMethod method);
}

// 2. 구체적인 Strategy 구현들
@Component
@RequiredArgsConstructor
public class CreditCardPaymentStrategy implements PaymentStrategy {
    
    private final CreditCardGateway creditCardGateway;
    
    @Override
    public PaymentResult pay(Order order) {
        CreditCardInfo cardInfo = order.getCreditCardInfo();
        
        // 카드 유효성 검증
        creditCardGateway.validate(cardInfo);
        
        // 결제 실행
        ChargeResult result = creditCardGateway.charge(
            cardInfo.getCardNumber(),
            cardInfo.getExpiry(),
            cardInfo.getCvv(),
            order.getTotalAmount()
        );
        
        return PaymentResult.success(
            result.getTransactionId(),
            PaymentMethod.CREDIT_CARD,
            order.getTotalAmount()
        );
    }
    
    @Override
    public PaymentMethod getPaymentMethod() {
        return PaymentMethod.CREDIT_CARD;
    }
    
    @Override
    public boolean supports(PaymentMethod method) {
        return PaymentMethod.CREDIT_CARD == method;
    }
}

@Component
@RequiredArgsConstructor
public class KakaoPayPaymentStrategy implements PaymentStrategy {
    
    private final KakaoPayClient kakaoPayClient;
    
    @Override
    public PaymentResult pay(Order order) {
        // 카카오페이 결제 준비
        ReadyResponse ready = kakaoPayClient.ready(
            order.getId(),
            order.getTotalAmount(),
            order.getItemName()
        );
        
        // 결제 승인 (실제로는 리다이렉트 후 콜백에서 처리)
        ApproveResponse approve = kakaoPayClient.approve(
            ready.getTid(),
            order.getCustomerId()
        );
        
        return PaymentResult.success(
            approve.getTid(),
            PaymentMethod.KAKAO_PAY,
            order.getTotalAmount()
        );
    }
    
    @Override
    public PaymentMethod getPaymentMethod() {
        return PaymentMethod.KAKAO_PAY;
    }
    
    @Override
    public boolean supports(PaymentMethod method) {
        return PaymentMethod.KAKAO_PAY == method;
    }
}

@Component
@RequiredArgsConstructor
public class NaverPayPaymentStrategy implements PaymentStrategy {
    
    private final NaverPayClient naverPayClient;
    
    @Override
    public PaymentResult pay(Order order) {
        NaverPayResponse response = naverPayClient.pay(
            order.getId(),
            order.getTotalAmount()
        );
        
        return PaymentResult.success(
            response.getPaymentId(),
            PaymentMethod.NAVER_PAY,
            order.getTotalAmount()
        );
    }
    
    @Override
    public PaymentMethod getPaymentMethod() {
        return PaymentMethod.NAVER_PAY;
    }
    
    @Override
    public boolean supports(PaymentMethod method) {
        return PaymentMethod.NAVER_PAY == method;
    }
}

3. Context 클래스 (Strategy 사용)

@Service
@RequiredArgsConstructor
public class PaymentService {
    
    // Spring이 모든 PaymentStrategy 구현체를 자동 주입
    private final List<PaymentStrategy> paymentStrategies;
    
    public PaymentResult processPayment(Order order, PaymentMethod paymentMethod) {
        // 적합한 Strategy 찾기
        PaymentStrategy strategy = paymentStrategies.stream()
            .filter(s -> s.supports(paymentMethod))
            .findFirst()
            .orElseThrow(() -> new UnsupportedPaymentMethodException(paymentMethod));
        
        // Strategy 실행
        return strategy.pay(order);
    }
}

// 또는 Map으로 관리
@Service
public class PaymentService {
    
    private final Map<PaymentMethod, PaymentStrategy> strategyMap;
    
    public PaymentService(List<PaymentStrategy> strategies) {
        this.strategyMap = strategies.stream()
            .collect(Collectors.toMap(
                PaymentStrategy::getPaymentMethod,
                Function.identity()
            ));
    }
    
    public PaymentResult processPayment(Order order, PaymentMethod paymentMethod) {
        PaymentStrategy strategy = strategyMap.get(paymentMethod);
        if (strategy == null) {
            throw new UnsupportedPaymentMethodException(paymentMethod);
        }
        return strategy.pay(order);
    }
}

새로운 결제 수단 추가하기

// 토스페이 추가 - 기존 코드 수정 없이 클래스만 추가!
@Component
@RequiredArgsConstructor
public class TossPayPaymentStrategy implements PaymentStrategy {
    
    private final TossPayClient tossPayClient;
    
    @Override
    public PaymentResult pay(Order order) {
        TossPayResponse response = tossPayClient.execute(
            order.getId(),
            order.getTotalAmount()
        );
        
        return PaymentResult.success(
            response.getPaymentKey(),
            PaymentMethod.TOSS_PAY,
            order.getTotalAmount()
        );
    }
    
    @Override
    public PaymentMethod getPaymentMethod() {
        return PaymentMethod.TOSS_PAY;
    }
    
    @Override
    public boolean supports(PaymentMethod method) {
        return PaymentMethod.TOSS_PAY == method;
    }
}

// PaymentService는 수정할 필요 없음!
// Spring이 자동으로 새 Strategy를 주입함

배송비 계산 Strategy

// Strategy 인터페이스
public interface ShippingFeeStrategy {
    Money calculateFee(Order order);
    ShippingType getShippingType();
}

// 일반 배송
@Component
public class StandardShippingStrategy implements ShippingFeeStrategy {
    
    private static final Money BASE_FEE = Money.of(3000);
    private static final Money FREE_THRESHOLD = Money.of(50000);
    
    @Override
    public Money calculateFee(Order order) {
        if (order.getTotalPrice().isGreaterThanOrEqual(FREE_THRESHOLD)) {
            return Money.ZERO;  // 5만원 이상 무료배송
        }
        return BASE_FEE;
    }
    
    @Override
    public ShippingType getShippingType() {
        return ShippingType.STANDARD;
    }
}

// 새벽 배송
@Component
public class DawnDeliveryStrategy implements ShippingFeeStrategy {
    
    private static final Money DAWN_FEE = Money.of(5000);
    
    @Override
    public Money calculateFee(Order order) {
        // 새벽 배송은 항상 5000원
        return DAWN_FEE;
    }
    
    @Override
    public ShippingType getShippingType() {
        return ShippingType.DAWN;
    }
}

// 당일 배송
@Component
public class SameDayDeliveryStrategy implements ShippingFeeStrategy {
    
    @Override
    public Money calculateFee(Order order) {
        // 거리에 따른 요금 계산
        int distance = calculateDistance(order.getDeliveryAddress());
        
        if (distance <= 10) {
            return Money.of(4000);
        } else if (distance <= 20) {
            return Money.of(6000);
        } else {
            return Money.of(8000);
        }
    }
    
    @Override
    public ShippingType getShippingType() {
        return ShippingType.SAME_DAY;
    }
}

// 사용
@Service
@RequiredArgsConstructor
public class ShippingService {
    
    private final Map<ShippingType, ShippingFeeStrategy> strategies;
    
    public ShippingService(List<ShippingFeeStrategy> strategyList) {
        this.strategies = strategyList.stream()
            .collect(Collectors.toMap(
                ShippingFeeStrategy::getShippingType,
                Function.identity()
            ));
    }
    
    public Money calculateShippingFee(Order order, ShippingType type) {
        ShippingFeeStrategy strategy = strategies.get(type);
        return strategy.calculateFee(order);
    }
}

요구사항

• • 다양한 결제 수단 지원 (신용카드, 카카오페이, 네이버페이)
• • 다양한 할인 정책 적용 (퍼센트, 정액, VIP)
• • 주문 처리 흐름은 동일하되, 결제/할인만 다름
• • 상품 정보는 캐싱하여 성능 최적화

1. 상품 캐시 (Singleton)

@Component
public class ProductCache {
    
    private final Cache<Long, Product> cache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(Duration.ofMinutes(10))
        .build();
    
    private final ProductRepository productRepository;
    
    public ProductCache(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
    
    public Product getProduct(Long productId) {
        return cache.get(productId, id -> 
            productRepository.findById(id)
                .orElseThrow(() -> new ProductNotFoundException(id))
        );
    }
    
    public List<Product> getProducts(List<Long> productIds) {
        return productIds.stream()
            .map(this::getProduct)
            .toList();
    }
    
    public void evict(Long productId) {
        cache.invalidate(productId);
    }
}

2. 할인 정책 (Strategy + Factory)

// Strategy 인터페이스
public interface DiscountPolicy {
    Money calculateDiscount(Order order);
    DiscountType getType();
}

// 구체적인 Strategy들
@Component
public class PercentDiscountPolicy implements DiscountPolicy {
    @Override
    public Money calculateDiscount(Order order) {
        Coupon coupon = order.getCoupon();
        return order.getTotalPrice().multiply(coupon.getDiscountRate());
    }
    
    @Override
    public DiscountType getType() {
        return DiscountType.PERCENT;
    }
}

@Component
public class FixedDiscountPolicy implements DiscountPolicy {
    @Override
    public Money calculateDiscount(Order order) {
        return order.getCoupon().getDiscountAmount();
    }
    
    @Override
    public DiscountType getType() {
        return DiscountType.FIXED;
    }
}

@Component
public class VipDiscountPolicy implements DiscountPolicy {
    private static final double VIP_RATE = 0.1;
    
    @Override
    public Money calculateDiscount(Order order) {
        if (order.getCustomer().isVip()) {
            return order.getTotalPrice().multiply(VIP_RATE);
        }
        return Money.ZERO;
    }
    
    @Override
    public DiscountType getType() {
        return DiscountType.VIP;
    }
}

// Factory Registry
@Component
public class DiscountPolicyRegistry {
    
    private final Map<DiscountType, DiscountPolicy> policies;
    
    public DiscountPolicyRegistry(List<DiscountPolicy> policyList) {
        this.policies = policyList.stream()
            .collect(Collectors.toMap(
                DiscountPolicy::getType,
                Function.identity()
            ));
    }
    
    public DiscountPolicy getPolicy(DiscountType type) {
        return policies.get(type);
    }
    
    public Money calculateTotalDiscount(Order order) {
        Money totalDiscount = Money.ZERO;
        
        // 쿠폰 할인
        if (order.hasCoupon()) {
            DiscountPolicy couponPolicy = getPolicy(order.getCoupon().getType());
            totalDiscount = totalDiscount.add(couponPolicy.calculateDiscount(order));
        }
        
        // VIP 할인 (중복 적용)
        DiscountPolicy vipPolicy = getPolicy(DiscountType.VIP);
        totalDiscount = totalDiscount.add(vipPolicy.calculateDiscount(order));
        
        return totalDiscount;
    }
}

3. 결제 처리 (Strategy)

// Strategy 인터페이스
public interface PaymentStrategy {
    PaymentResult pay(PaymentRequest request);
    PaymentMethod getMethod();
}

// 구체적인 Strategy들
@Component
@RequiredArgsConstructor
public class CreditCardPaymentStrategy implements PaymentStrategy {
    private final CreditCardGateway gateway;
    
    @Override
    public PaymentResult pay(PaymentRequest request) {
        ChargeResult result = gateway.charge(
            request.getCardInfo(),
            request.getAmount()
        );
        return PaymentResult.of(result.getTransactionId(), getMethod());
    }
    
    @Override
    public PaymentMethod getMethod() {
        return PaymentMethod.CREDIT_CARD;
    }
}

@Component
@RequiredArgsConstructor
public class KakaoPayPaymentStrategy implements PaymentStrategy {
    private final KakaoPayClient client;
    
    @Override
    public PaymentResult pay(PaymentRequest request) {
        KakaoPayResponse response = client.pay(
            request.getOrderId(),
            request.getAmount()
        );
        return PaymentResult.of(response.getTid(), getMethod());
    }
    
    @Override
    public PaymentMethod getMethod() {
        return PaymentMethod.KAKAO_PAY;
    }
}

// Payment Service
@Service
public class PaymentService {
    
    private final Map<PaymentMethod, PaymentStrategy> strategies;
    
    public PaymentService(List<PaymentStrategy> strategyList) {
        this.strategies = strategyList.stream()
            .collect(Collectors.toMap(
                PaymentStrategy::getMethod,
                Function.identity()
            ));
    }
    
    public PaymentResult processPayment(PaymentRequest request) {
        PaymentStrategy strategy = strategies.get(request.getPaymentMethod());
        if (strategy == null) {
            throw new UnsupportedPaymentMethodException(request.getPaymentMethod());
        }
        return strategy.pay(request);
    }
}

4. 주문 처리 (Template Method)

@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final ProductCache productCache;
    private final DiscountPolicyRegistry discountRegistry;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    @Transactional
    public Order createOrder(OrderCreateRequest request) {
        // 1. 상품 조회 (캐시 활용)
        List<Product> products = productCache.getProducts(
            request.getItems().stream()
                .map(OrderItemRequest::getProductId)
                .toList()
        );
        
        // 2. 주문 생성
        Order order = Order.create(request.getCustomer(), products, request.getItems());
        
        // 3. 할인 적용 (Strategy)
        Money discount = discountRegistry.calculateTotalDiscount(order);
        order.applyDiscount(discount);
        
        // 4. 재고 확인 및 차감
        for (OrderItem item : order.getItems()) {
            inventoryService.decrease(item.getProductId(), item.getQuantity());
        }
        
        // 5. 결제 처리 (Strategy)
        PaymentRequest paymentRequest = PaymentRequest.builder()
            .orderId(order.getId())
            .amount(order.getFinalPrice())
            .paymentMethod(request.getPaymentMethod())
            .cardInfo(request.getCardInfo())
            .build();
        
        PaymentResult paymentResult = paymentService.processPayment(paymentRequest);
        order.completePayment(paymentResult);
        
        // 6. 주문 저장
        Order savedOrder = orderRepository.save(order);
        
        // 7. 이벤트 발행
        eventPublisher.publishEvent(new OrderCreatedEvent(savedOrder));
        
        return savedOrder;
    }
}

5. Facade (복잡성 숨김)

@Service
@RequiredArgsConstructor
public class OrderFacadeService {
    
    private final OrderService orderService;
    private final CustomerService customerService;
    private final CouponService couponService;
    private final NotificationService notificationService;
    
    /**
     * 클라이언트에게 단순한 인터페이스 제공
     * 내부의 복잡한 서브시스템 호출을 숨김
     */
    public OrderResponse createOrder(OrderRequest request) {
        // 1. 고객 조회
        Customer customer = customerService.getCustomer(request.getCustomerId());
        
        // 2. 쿠폰 검증 및 적용
        Coupon coupon = null;
        if (request.getCouponCode() != null) {
            coupon = couponService.validateAndUse(request.getCouponCode(), customer);
        }
        
        // 3. 주문 생성 요청 구성
        OrderCreateRequest createRequest = OrderCreateRequest.builder()
            .customer(customer)
            .items(request.getItems())
            .coupon(coupon)
            .paymentMethod(request.getPaymentMethod())
            .cardInfo(request.getCardInfo())
            .shippingAddress(request.getShippingAddress())
            .build();
        
        // 4. 주문 생성
        Order order = orderService.createOrder(createRequest);
        
        // 5. 알림 발송
        notificationService.sendOrderConfirmation(order);
        
        // 6. 응답 변환
        return OrderResponse.from(order);
    }
}

// Controller는 Facade만 호출
@RestController
@RequestMapping("/api/orders")
@RequiredArgsConstructor
public class OrderController {
    
    private final OrderFacadeService orderFacade;
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody @Valid OrderRequest request) {
        OrderResponse response = orderFacade.createOrder(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }
}

* 회색 배경: 다음 세션에서 학습할 패턴