Spring 13: 비동기 처리

@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    // 동기 처리 - 응답까지 3초 소요
    @GetMapping("/users/{id}/profile-sync")
    public ResponseEntity<UserProfile> getUserProfileSync(@PathVariable Long id) {
        UserProfile profile = userService.getUserProfileSync(id);
        return ResponseEntity.ok(profile);
    }
    
    // 비동기 처리 - 즉시 응답, 백그라운드에서 처리
    @GetMapping("/users/{id}/profile-async")
    public CompletableFuture<ResponseEntity<UserProfile>> getUserProfileAsync(@PathVariable Long id) {
        return userService.getUserProfileAsync(id)
            .thenApply(ResponseEntity::ok);
    }
}

@Service
public class NotificationService {
    
    @Async
    public CompletableFuture<Void> sendWelcomeEmail(User user) {
        return CompletableFuture.runAsync(() -> {
            // 이메일 템플릿 생성
            EmailTemplate template = createWelcomeTemplate(user);
            
            // 외부 이메일 서비스 호출
            emailProvider.send(template);
            
            log.info("환영 이메일 발송 완료: {}", user.getEmail());
        });
    }
    
    @Async
    public CompletableFuture<Void> sendOrderConfirmation(Order order) {
        return CompletableFuture.runAsync(() -> {
            // 주문 확인 이메일 발송
            EmailTemplate template = createOrderTemplate(order);
            emailProvider.send(template);
            
            // SMS 알림도 함께 발송
            smsProvider.send(order.getUser().getPhone(), 
                "주문이 완료되었습니다. 주문번호: " + order.getId());
                
            log.info("주문 확인 알림 발송 완료: {}", order.getId());
        });
    }
}

@Service
public class DataProcessingService {
    
    @Async
    public CompletableFuture<ProcessingResult> processLargeDataset(Dataset dataset) {
        return CompletableFuture.supplyAsync(() -> {
            log.info("데이터 처리 시작: {} records", dataset.getSize());
            
            ProcessingResult result = new ProcessingResult();
            
            // 청크 단위로 데이터 처리
            List<DataChunk> chunks = dataset.splitIntoChunks(1000);
            
            for (DataChunk chunk : chunks) {
                ProcessingResult chunkResult = processChunk(chunk);
                result.merge(chunkResult);
                
                // 진행률 업데이트
                updateProgress(dataset.getId(), result.getProcessedCount(), dataset.getSize());
            }
            
            log.info("데이터 처리 완료: {}", dataset.getId());
            return result;
        });
    }
    
    @Async
    public CompletableFuture<Report> generateMonthlyReport(int year, int month) {
        return CompletableFuture.supplyAsync(() -> {
            // 월간 리포트 생성 (시간 소요 작업)
            Report report = new Report();
            
            // 각종 통계 데이터 수집
            report.setSalesData(collectSalesData(year, month));
            report.setUserData(collectUserData(year, month));
            report.setPerformanceData(collectPerformanceData(year, month));
            
            // 리포트 파일 생성
            String filePath = generateReportFile(report);
            report.setFilePath(filePath);
            
            return report;
        });
    }
}

@Service
public class ExternalApiService {
    
    @Async
    public CompletableFuture<PaymentResult> processPayment(PaymentRequest request) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // 외부 결제 API 호출
                PaymentResponse response = paymentGateway.charge(request);
                
                if (response.isSuccess()) {
                    // 결제 성공 처리
                    return PaymentResult.success(response.getTransactionId());
                } else {
                    // 결제 실패 처리
                    return PaymentResult.failure(response.getErrorMessage());
                }
            } catch (Exception e) {
                log.error("결제 처리 중 오류 발생", e);
                return PaymentResult.error(e.getMessage());
            }
        });
    }
    
    @Async
    public CompletableFuture<List<Product>> fetchProductsFromMultipleSources(String category) {
        // 여러 외부 소스에서 상품 정보를 병렬로 가져오기
        CompletableFuture<List<Product>> source1 = CompletableFuture.supplyAsync(() -> 
            externalApi1.getProducts(category));
            
        CompletableFuture<List<Product>> source2 = CompletableFuture.supplyAsync(() -> 
            externalApi2.getProducts(category));
            
        CompletableFuture<List<Product>> source3 = CompletableFuture.supplyAsync(() -> 
            externalApi3.getProducts(category));
        
        return CompletableFuture.allOf(source1, source2, source3)
            .thenApply(v -> {
                List<Product> allProducts = new ArrayList<>();
                allProducts.addAll(source1.join());
                allProducts.addAll(source2.join());
                allProducts.addAll(source3.join());
                return allProducts;
            });
    }
}

@Component
public class EventHandler {
    
    @EventListener
    @Async
    public void handleUserRegistration(UserRegisteredEvent event) {
        User user = event.getUser();
        
        // 여러 후속 작업을 비동기로 처리
        CompletableFuture.allOf(
            sendWelcomeEmail(user),
            createUserProfile(user),
            setupDefaultSettings(user),
            logUserActivity(user)
        ).thenRun(() -> {
            log.info("사용자 등록 후속 처리 완료: {}", user.getId());
        });
    }
    
    @EventListener
    @Async
    public void handleOrderPlaced(OrderPlacedEvent event) {
        Order order = event.getOrder();
        
        // 주문 관련 비동기 처리
        CompletableFuture.allOf(
            updateInventory(order),
            sendOrderConfirmation(order),
            notifyWarehouse(order),
            updateAnalytics(order)
        ).thenRun(() -> {
            log.info("주문 처리 완료: {}", order.getId());
        });
    }
    
    private CompletableFuture<Void> sendWelcomeEmail(User user) {
        return CompletableFuture.runAsync(() -> {
            // 환영 이메일 발송 로직
        });
    }
    
    private CompletableFuture<Void> updateInventory(Order order) {
        return CompletableFuture.runAsync(() -> {
            // 재고 업데이트 로직
        });
    }
}