Aggregate 심화#

// 문제 1: 어디서든 내부 객체 직접 수정 가능
OrderLine line = orderLineRepository.findById(lineId);
line.setQuantity(100);  // 주문 총액 업데이트 안 됨! 불일치 발생

// 문제 2: 트랜잭션 범위가 불명확
@Transactional
public void processOrder(OrderId orderId) {
    // Order, OrderLine, Customer, Product, Stock, Payment...
    // 전부 한 트랜잭션? 어디까지?
}

// 문제 3: 동시성 제어 불가능
// 사용자 A: order.addLine(...)
// 사용자 B: order.removeLine(...)
// 누가 이기는가? 어떤 락을 잡아야 하는가?

public class Order {
    private List<OrderLine> orderLines;
    private Money totalAmount;
    private OrderStatus status;

    // 불변식: 주문 항목이 비어있으면 안 됨
    public void removeOrderLine(OrderLineId lineId) {
        if (orderLines.size() <= 1) {
            throw new BusinessRuleViolationException(
                "주문에는 최소 1개의 항목이 있어야 합니다"
            );
        }
        orderLines.removeIf(line -> line.getId().equals(lineId));
        recalculateTotal();  // 불변식: 총액은 항상 최신
    }

    // 불변식: 총액은 주문 항목 합계와 일치
    private void recalculateTotal() {
        this.totalAmount = orderLines.stream()
            .map(OrderLine::getAmount)
            .reduce(Money.ZERO, Money::add);
    }
}

// 측정 코드 예시
@Around("execution(* *Repository.save(..))")
public Object measureSaveTime(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currentTimeMillis();
    try {
        return pjp.proceed();
    } finally {
        long duration = System.currentTimeMillis() - start;
        if (duration > 50) {
            log.warn("Slow aggregate save: {}ms, type={}",
                duration, pjp.getArgs()[0].getClass().getSimpleName());
        }
        metrics.recordSaveTime(pjp.getSignature().getName(), duration);
    }
}

// ❌ 객체 직접 참조
public class Order {
    private Customer customer;  // Customer Aggregate 직접 참조
    private List<Product> products;  // Product Aggregate 직접 참조
}

// ✅ ID로 참조
public class Order {
    private CustomerId customerId;  // ID만 보관
    private List<OrderLine> orderLines;  // OrderLine 내부에 ProductId
}

public record OrderLine(
    OrderLineId id,
    ProductId productId,  // ID로 참조
    String productName,   // 필요한 정보는 복사
    Money price,
    int quantity
) {}

// Order Aggregate
public class Order {
    public void confirm() {
        this.status = OrderStatus.CONFIRMED;
        // 이벤트만 발행, 재고는 별도 트랜잭션
        registerEvent(new OrderConfirmedEvent(this.id, this.orderLines));
    }
}

// Stock Aggregate (별도 트랜잭션)
@Component
public class StockEventHandler {

    private final StockRepository stockRepository;

    // 주의: @EventListener는 같은 트랜잭션에서 동기 실행됨
    // 별도 트랜잭션이 필요하면 아래와 같이 설정
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void handle(OrderConfirmedEvent event) {
        for (OrderLineInfo line : event.getOrderLines()) {
            Stock stock = stockRepository.findByProductId(line.getProductId());
            stock.reserve(line.getQuantity());
            stockRepository.save(stock);
        }
    }
}

// ✅ 올바른 패턴: 하나의 Aggregate만 수정
@Transactional
public void confirmOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId)
        .orElseThrow(() -> new OrderNotFoundException(orderId));

    order.confirm();  // Order Aggregate만 수정

    orderRepository.save(order);
    // 이벤트로 다른 Aggregate 변경 유도
}

// ❌ 잘못된 패턴: 여러 Aggregate 동시 수정
@Transactional
public void confirmOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    order.confirm();

    // 같은 트랜잭션에서 다른 Aggregate 수정 - 피해야 함
    for (OrderLine line : order.getOrderLines()) {
        Stock stock = stockRepository.findByProductId(line.getProductId());
        stock.reserve(line.getQuantity());  // Stock Aggregate 수정
    }
}

// ❌ 너무 큰 Aggregate
public class Order {
    private Customer customer;        // 별도 Aggregate여야 함
    private List<Product> products;   // 별도 Aggregate여야 함
    private Payment payment;          // 별도 Aggregate여야 함
    private Delivery delivery;        // 별도 Aggregate여야 함
}

// 문제점:
// 1. Customer 정보 수정할 때마다 Order를 로드해야 함
// 2. 재고 확인하려면 모든 Order를 뒤져야 함
// 3. 동시 주문 시 불필요한 충돌 발생

// ✅ 적절한 크기
public class Order {
    private CustomerId customerId;
    private String customerName;  // 표시용 복사본
    private List<OrderLine> orderLines;  // OrderLine만 포함
}

// ❌ Aggregate에서 Repository 직접 호출
public class Order {
    @Autowired  // 절대 안 됨!
    private ProductRepository productRepository;

    public void addItem(ProductId productId, int quantity) {
        Product product = productRepository.findById(productId);  // 안티패턴!
        this.orderLines.add(new OrderLine(product, quantity));
    }
}

// ✅ 서비스에서 조회 후 전달
@Service
public class OrderService {
    public void addItem(OrderId orderId, ProductId productId, int quantity) {
        Order order = orderRepository.findById(orderId);
        ProductInfo productInfo = productService.getProductInfo(productId);

        order.addItem(productInfo, quantity);  // 필요한 정보만 전달

        orderRepository.save(order);
    }
}

// ❌ 내부 Entity 직접 조회/수정
OrderLine line = orderLineRepository.findById(lineId);
line.setQuantity(10);  // Order의 totalAmount는 업데이트 안 됨!
orderLineRepository.save(line);

// ✅ Root를 통한 수정
Order order = orderRepository.findById(orderId);
order.changeLineQuantity(lineId, 10);  // 내부에서 총액도 재계산
orderRepository.save(order);

// ❌ 한 트랜잭션에서 여러 Aggregate 수정
@Transactional
public void processOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId);
    order.confirm();

    Stock stock = stockRepository.findByProductId(productId);
    stock.decrease(quantity);  // 다른 Aggregate 수정!

    Customer customer = customerRepository.findById(customerId);
    customer.addPoints(points);  // 또 다른 Aggregate 수정!
}
// 문제: 락 범위가 넓어지고, 동시성 이슈 발생

// ✅ 각각 별도 트랜잭션
@Transactional
public void confirmOrder(OrderId orderId) {
    Order order = orderRepository.findById(orderId);
    order.confirm();  // OrderConfirmedEvent 발행
    orderRepository.save(order);
}

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void onOrderConfirmed(OrderConfirmedEvent event) {
    Stock stock = stockRepository.findByProductId(event.getProductId());
    stock.decrease(event.getQuantity());
    stockRepository.save(stock);
}

// Anti-Corruption Layer
@Service
public class OrderAntiCorruptionLayer {

    private final LegacyOrderDao legacyDao;  // 기존 시스템
    private final OrderRepository newRepo;   // 새 Aggregate

    // 레거시 → 새 모델
    public Order findOrder(String legacyOrderId) {
        LegacyOrderEntity legacy = legacyDao.findById(legacyOrderId);
        return translateToAggregate(legacy);
    }

    // 새 모델 → 레거시 (역방향 호환)
    public void saveOrder(Order order) {
        newRepo.save(order);
        // 레거시 시스템도 업데이트 (전환 기간 동안)
        legacyDao.update(translateToLegacy(order));
    }

    private Order translateToAggregate(LegacyOrderEntity legacy) {
        return Order.reconstitute(
            new OrderId(legacy.getOrderNumber()),
            translateOrderLines(legacy.getItems()),
            // ... 변환 로직
        );
    }
}