제17강: 백엔드 프레임워크와 Cursor AI

AI가 생성한 Spring Boot 서비스

// OrderService.java
package com.example.ecommerce.service;

import com.example.ecommerce.dto.OrderDTO;
import com.example.ecommerce.dto.OrderItemDTO;
import com.example.ecommerce.entity.Order;
import com.example.ecommerce.entity.OrderItem;
import com.example.ecommerce.entity.Product;
import com.example.ecommerce.entity.User;
import com.example.ecommerce.exception.InsufficientStockException;
import com.example.ecommerce.exception.ResourceNotFoundException;
import com.example.ecommerce.mapper.OrderMapper;
import com.example.ecommerce.repository.OrderRepository;
import com.example.ecommerce.repository.ProductRepository;
import com.example.ecommerce.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final UserRepository userRepository;
    private final ProductRepository productRepository;
    private final OrderMapper orderMapper;
    private final KafkaTemplate kafkaTemplate;
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    
    @Transactional
    public OrderDTO createOrder(OrderDTO orderDTO, String userId) {
        log.info("Creating order for user: {}", userId);
        
        // 사용자 확인
        User user = userRepository.findById(UUID.fromString(userId))
            .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        
        // 주문 생성
        Order order = new Order();
        order.setUser(user);
        order.setOrderNumber(generateOrderNumber());
        order.setStatus(Order.OrderStatus.PENDING);
        order.setCreatedAt(LocalDateTime.now());
        
        // 주문 항목 처리
        BigDecimal totalAmount = BigDecimal.ZERO;
        
        for (OrderItemDTO itemDTO : orderDTO.getItems()) {
            Product product = productRepository.findById(itemDTO.getProductId())
                .orElseThrow(() -> new ResourceNotFoundException("Product not found"));
            
            // 재고 확인
            if (!inventoryService.checkStock(product.getId(), itemDTO.getQuantity())) {
                throw new InsufficientStockException(
                    "Insufficient stock for product: " + product.getName()
                );
            }
            
            OrderItem orderItem = new OrderItem();
            orderItem.setOrder(order);
            orderItem.setProduct(product);
            orderItem.setQuantity(itemDTO.getQuantity());
            orderItem.setPrice(product.getPrice());
            orderItem.setSubtotal(
                product.getPrice().multiply(BigDecimal.valueOf(itemDTO.getQuantity()))
            );
            
            order.getItems().add(orderItem);
            totalAmount = totalAmount.add(orderItem.getSubtotal());
        }
        
        order.setTotalAmount(totalAmount);
        
        // 재고 차감
        for (OrderItem item : order.getItems()) {
            inventoryService.decreaseStock(
                item.getProduct().getId(), 
                item.getQuantity()
            );
        }
        
        // 주문 저장
        Order savedOrder = orderRepository.save(order);
        
        // 결제 처리
        try {
            PaymentResult paymentResult = paymentService.processPayment(
                savedOrder.getId(),
                totalAmount,
                orderDTO.getPaymentMethod()
            );
            
            if (paymentResult.isSuccess()) {
                savedOrder.setStatus(Order.OrderStatus.PAID);
                savedOrder.setPaymentId(paymentResult.getTransactionId());
            } else {
                // 재고 복원
                rollbackInventory(savedOrder);
                savedOrder.setStatus(Order.OrderStatus.PAYMENT_FAILED);
            }
        } catch (Exception e) {
            log.error("Payment processing failed", e);
            rollbackInventory(savedOrder);
            savedOrder.setStatus(Order.OrderStatus.PAYMENT_FAILED);
        }
        
        savedOrder = orderRepository.save(savedOrder);
        
        // 이벤트 발행
        publishOrderEvent(savedOrder);
        
        return orderMapper.toDTO(savedOrder);
    }
    
    @Transactional(readOnly = true)
    @Cacheable(value = "orders", key = "#orderId")
    public OrderDTO getOrder(String orderId) {
        Order order = orderRepository.findById(UUID.fromString(orderId))
            .orElseThrow(() -> new ResourceNotFoundException("Order not found"));
        
        return orderMapper.toDTO(order);
    }
    
    @Transactional(readOnly = true)
    public Page getUserOrders(String userId, Pageable pageable) {
        Page orders = orderRepository.findByUserIdOrderByCreatedAtDesc(
            UUID.fromString(userId), 
            pageable
        );
        
        return orders.map(orderMapper::toDTO);
    }
    
    @Transactional
    @CacheEvict(value = "orders", key = "#orderId")
    public OrderDTO updateOrderStatus(String orderId, Order.OrderStatus status) {
        Order order = orderRepository.findById(UUID.fromString(orderId))
            .orElseThrow(() -> new ResourceNotFoundException("Order not found"));
        
        Order.OrderStatus previousStatus = order.getStatus();
        order.setStatus(status);
        order.setUpdatedAt(LocalDateTime.now());
        
        // 상태 변경에 따른 처리
        switch (status) {
            case SHIPPED:
                order.setShippedAt(LocalDateTime.now());
                sendShipmentNotification(order);
                break;
            case DELIVERED:
                order.setDeliveredAt(LocalDateTime.now());
                sendDeliveryNotification(order);
                break;
            case CANCELLED:
                handleOrderCancellation(order);
                break;
        }
        
        Order updatedOrder = orderRepository.save(order);
        
        // 상태 변경 이벤트 발행
        publishStatusChangeEvent(updatedOrder, previousStatus);
        
        return orderMapper.toDTO(updatedOrder);
    }
    
    @Transactional
    public void cancelOrder(String orderId, String reason) {
        Order order = orderRepository.findById(UUID.fromString(orderId))
            .orElseThrow(() -> new ResourceNotFoundException("Order not found"));
        
        // 취소 가능 상태 확인
        if (!order.isCancellable()) {
            throw new IllegalStateException(
                "Order cannot be cancelled in current status: " + order.getStatus()
            );
        }
        
        // 재고 복원
        rollbackInventory(order);
        
        // 환불 처리
        if (order.getPaymentId() != null) {
            paymentService.refund(order.getPaymentId(), order.getTotalAmount());
        }
        
        order.setStatus(Order.OrderStatus.CANCELLED);
        order.setCancellationReason(reason);
        order.setCancelledAt(LocalDateTime.now());
        
        orderRepository.save(order);
        
        // 취소 알림
        sendCancellationNotification(order);
    }
    
    private String generateOrderNumber() {
        return "ORD-" + System.currentTimeMillis() + "-" + 
               UUID.randomUUID().toString().substring(0, 8).toUpperCase();
    }
    
    private void rollbackInventory(Order order) {
        for (OrderItem item : order.getItems()) {
            inventoryService.increaseStock(
                item.getProduct().getId(), 
                item.getQuantity()
            );
        }
    }
    
    private void publishOrderEvent(Order order) {
        OrderEvent event = new OrderEvent(
            order.getId(),
            order.getOrderNumber(),
            order.getStatus(),
            order.getTotalAmount(),
            order.getUser().getEmail()
        );
        
        kafkaTemplate.send("order-events", event);
    }
    
    private void publishStatusChangeEvent(Order order, Order.OrderStatus previousStatus) {
        StatusChangeEvent event = new StatusChangeEvent(
            order.getId(),
            previousStatus,
            order.getStatus(),
            LocalDateTime.now()
        );
        
        kafkaTemplate.send("order-status-events", event);
    }
    
    private void sendShipmentNotification(Order order) {
        // 배송 알림 로직
    }
    
    private void sendDeliveryNotification(Order order) {
        // 배달 완료 알림 로직
    }
    
    private void sendCancellationNotification(Order order) {
        // 취소 알림 로직
    }
}