Synchronous vs Asynchronous APIs

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        // 사용자 조회 (이 작업이 완료될 때까지 클라이언트는 대기)
        User user = userService.findById(id);
        
        if (user != null) {
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 작업 제출 엔드포인트
@PostMapping("/api/jobs")
public ResponseEntity<JobResponse> submitJob(@RequestBody JobRequest request) {
    // 작업을 큐에 추가하고 작업 ID 반환
    String jobId = jobService.enqueueJob(request);
    
    return ResponseEntity
        .accepted()
        .body(new JobResponse(jobId, "PENDING"));
}

// 작업 상태 확인 엔드포인트 (폴링용)
@GetMapping("/api/jobs/{jobId}")
public ResponseEntity<JobResponse> getJobStatus(@PathVariable String jobId) {
    Job job = jobService.getJob(jobId);
    
    if (job == null) {
        return ResponseEntity.notFound().build();
    }
    
    JobResponse response = new JobResponse(
        job.getId(),
        job.getStatus().toString()
    );
    
    // 작업이 완료된 경우 결과 포함
    if (job.getStatus() == JobStatus.COMPLETED) {
        response.setResult(job.getResult());
    }
    
    return ResponseEntity.ok(response);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

@PostMapping("/api/reports/generate")
public ResponseEntity<ReportResponse> generateReport(
    @RequestBody ReportRequest request,
    @RequestParam String callbackUrl) {
    
    // 보고서 생성 작업 ID 생성
    String reportId = UUID.randomUUID().toString();
    
    // 비동기적으로 보고서 생성 작업 시작 (별도 스레드/작업자)
    reportService.generateReportAsync(reportId, request, callbackUrl);
    
    return ResponseEntity
        .accepted()
        .body(new ReportResponse(reportId, "Report generation started"));
}

// 서비스 내부에서 콜백 실행
public void notifyReportCompletion(String reportId, String callbackUrl, Report report) {
    ReportResult result = new ReportResult(reportId, "COMPLETED", report.getUrl());
    
    try {
        // 콜백 URL로 결과 전송
        restTemplate.postForEntity(callbackUrl, result, Void.class);
    } catch (Exception e) {
        log.error("Failed to send callback for report {}: {}", reportId, e.getMessage());
        // 재시도 로직이나 대체 알림 메커니즘 구현 가능
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// SSE를 사용한 이벤트 스트리밍 예시
@GetMapping(value = "/api/jobs/{jobId}/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter streamJobEvents(@PathVariable String jobId) {
    SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);
    
    // 이미터를 작업 ID에 연결
    jobEventService.addEmitter(jobId, emitter);
    
    // 연결 종료 시 정리
    emitter.onCompletion(() -> jobEventService.removeEmitter(jobId, emitter));
    emitter.onTimeout(() -> jobEventService.removeEmitter(jobId, emitter));
    
    // 초기 연결 확인 이벤트 전송
    try {
        emitter.send(SseEmitter.event()
            .name("CONNECTED")
            .data(Map.of("jobId", jobId, "message", "Connected to job events"))
        );
    } catch (IOException e) {
        emitter.completeWithError(e);
    }
    
    return emitter;
}

// 작업 처리 과정에서 이벤트 전송
public void sendJobEvent(String jobId, String eventType, Object data) {
    List<SseEmitter> emitters = jobEventService.getEmitters(jobId);
    
    if (emitters.isEmpty()) {
        return;
    }
    
    List<SseEmitter> deadEmitters = new ArrayList<>();
    
    for (SseEmitter emitter : emitters) {
        try {
            emitter.send(SseEmitter.event()
                .name(eventType)
                .data(data)
            );
        } catch (Exception e) {
            deadEmitters.add(emitter);
        }
    }
    
    // 실패한 이미터 제거
    deadEmitters.forEach(emitter -> jobEventService.removeEmitter(jobId, emitter));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

@PostMapping("/api/orders")
public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
    // 주문 ID 생성
    String orderId = UUID.randomUUID().toString();
    
    // 초기 주문 정보 저장
    Order order = orderRepository.save(new Order(orderId, request, OrderStatus.PROCESSING));
    
    // 메시지 큐로 주문 처리 작업 전송
    orderMessageProducer.sendOrderProcessingMessage(orderId, request);
    
    // 즉시 응답 반환
    return ResponseEntity
        .accepted()
        .body(new OrderResponse(orderId, OrderStatus.PROCESSING));
}

// 메시지 소비자 (별도 서비스/컴포넌트)
@Component
public class OrderProcessingConsumer {
    
    @RabbitListener(queues = "order-processing-queue")
    public void processOrder(OrderProcessingMessage message) {
        try {
            // 주문 처리 로직 
            Order order = orderService.processOrder(message.getOrderId(), message.getOrderRequest());
            
            // 주문 상태 업데이트
            orderRepository.updateStatus(order.getId(), OrderStatus.COMPLETED);
            
            // 완료 메시지 발행 (알림용)
            orderCompletionProducer.sendOrderCompletedMessage(order);
        } catch (Exception e) {
            log.error("Order processing failed for order {}: {}", message.getOrderId(), e.getMessage());
            orderRepository.updateStatus(message.getOrderId(), OrderStatus.FAILED);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

@PostMapping("/api/documents/convert")
public ResponseEntity<ConversionResponse> convertDocument(
    @RequestParam("file") MultipartFile file,
    @RequestParam("targetFormat") String targetFormat) {
    
    // 파일 저장 및 작업 메타데이터 생성 (동기식)
    String documentId = documentService.saveDocument(file);
    String conversionId = conversionService.createConversionJob(documentId, targetFormat);
    
    // 비동기 변환 작업 시작
    conversionService.startAsyncConversion(conversionId);
    
    // 작업 상태 확인 URL 및 작업 ID 반환 (동기식 응답)
    return ResponseEntity
        .accepted()
        .body(new ConversionResponse(
            conversionId,
            "/api/documents/conversions/" + conversionId,
            "PROCESSING"
        ));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

@GetMapping("/api/jobs/{jobId}/longpoll")
public ResponseEntity<JobResult> longPollJobResult(
    @PathVariable String jobId,
    @RequestParam(defaultValue = "30") int timeoutSeconds) {
    
    // 현재 작업 상태 확인
    JobStatus currentStatus = jobService.getJobStatus(jobId);
    
    // 이미 완료된 경우 즉시 결과 반환
    if (currentStatus == JobStatus.COMPLETED || currentStatus == JobStatus.FAILED) {
        return ResponseEntity.ok(jobService.getJobResult(jobId));
    }
    
    // 결과를 기다리는 CountDownLatch 생성
    CountDownLatch latch = new CountDownLatch(1);
    JobResultListener listener = new JobResultListener(jobId, latch);
    
    // 리스너 등록
    jobService.addJobListener(jobId, listener);
    
    try {
        // 결과를 기다리거나 타임아웃까지 대기
        boolean completed = latch.await(timeoutSeconds, TimeUnit.SECONDS);
        
        // 리스너 제거
        jobService.removeJobListener(jobId, listener);
        
        if (completed) {
            // 완료된 경우 결과 반환
            return ResponseEntity.ok(jobService.getJobResult(jobId));
        } else {
            // 타임아웃된 경우 현재 상태 반환
            return ResponseEntity.ok(new JobResult(jobId, jobService.getJobStatus(jobId), null));
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        jobService.removeJobListener(jobId, listener);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 동기식 처리 (간단한 요청용)
@PostMapping("/api/payments/sync")
public ResponseEntity<PaymentResult> processPaymentSync(@RequestBody PaymentRequest request) {
    // 동기적으로 결제 처리 (타임아웃 제한 있음)
    PaymentResult result = paymentService.processPaymentSync(request);
    return ResponseEntity.ok(result);
}

// 비동기식 처리 (복잡한 처리용)
@PostMapping("/api/payments/async")
public ResponseEntity<PaymentResponse> processPaymentAsync(
    @RequestBody PaymentRequest request,
    @RequestParam(required = false) String callbackUrl) {
    
    // 결제 작업 생성
    String paymentId = paymentService.initiatePayment(request);
    
    // 비동기 처리 시작
    paymentService.processPaymentAsync(paymentId, callbackUrl);
    
    // 즉시 응답
    return ResponseEntity
        .accepted()
        .body(new PaymentResponse(
            paymentId,
            "PROCESSING",
            "/api/payments/" + paymentId
        ));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// JavaScript를 사용한 AWS S3 멀티파트 업로드 예제
async function initiateMultipartUpload(s3Client, bucket, key) {
  const command = new CreateMultipartUploadCommand({
    Bucket: bucket,
    Key: key,
  });
  
  // 업로드 초기화 (동기식 부분)
  const { UploadId } = await s3Client.send(command);
  console.log(`Multipart upload initiated with UploadId: ${UploadId}`);
  
  return UploadId;
}

async function uploadPart(s3Client, bucket, key, uploadId, partNumber, body) {
  const command = new UploadPartCommand({
    Bucket: bucket,
    Key: key,
    UploadId: uploadId,
    PartNumber: partNumber,
    Body: body,
  });
  
  // 파트 업로드 (각 파트는 비동기식으로 처리)
  const { ETag } = await s3Client.send(command);
  console.log(`Part ${partNumber} uploaded, ETag: ${ETag}`);
  
  return { PartNumber: partNumber, ETag };
}

async function completeMultipartUpload(s3Client, bucket, key, uploadId, parts) {
  const command = new CompleteMultipartUploadCommand({
    Bucket: bucket,
    Key: key,
    UploadId: uploadId,
    MultipartUpload: { Parts: parts },
  });
  
  // 업로드 완료 (동기식 부분)
  const result = await s3Client.send(command);
  console.log(`Upload completed, Location: ${result.Location}`);
  
  return result;
}

// 대용량 파일을 청크로 나누어 병렬 업로드
async function uploadLargeFile(s3Client, bucket, key, fileStream, chunkSize) {
  // 1. 멀티파트 업로드 초기화
  const uploadId = await initiateMultipartUpload(s3Client, bucket, key);
  
  // 2. 파일을 청크로 분할하고 각 부분 비동기적으로 업로드
  const partPromises = [];
  let partNumber = 1;
  
  // 파일 청크 처리 로직 (스트림 처리)
  for await (const chunk of createChunkStream(fileStream, chunkSize)) {
    partPromises.push(
      uploadPart(s3Client, bucket, key, uploadId, partNumber++, chunk)
    );
  }
  
  // 모든 파트 업로드 완료 대기
  const uploadedParts = await Promise.all(partPromises);
  
  // 3. 멀티파트 업로드 완료
  return completeMultipartUpload(s3Client, bucket, key, uploadId, uploadedParts);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

@RestController
@RequestMapping("/api/v1/payments")
public class PaymentController {

    private final PaymentService paymentService;
    private final PaymentRepository paymentRepository;
    private final WebhookService webhookService;

    // 결제 인증 및 초기화 (동기식)
    @PostMapping("/authorize")
    public ResponseEntity<PaymentAuthorizationResponse> authorizePayment(
            @RequestBody PaymentAuthorizationRequest request) {
        
        // 기본 유효성 검사 및 결제 인증 (빠르게 처리되어야 함)
        PaymentAuthorization auth = paymentService.authorizePayment(request);
        
        return ResponseEntity.ok(new PaymentAuthorizationResponse(
            auth.getAuthorizationId(),
            auth.getStatus(),
            auth.getRedirectUrl()  // 3D Secure 등에 필요할 경우
        ));
    }
    
    // 결제 처리 (비동기식)
    @PostMapping("/process")
    public ResponseEntity<PaymentResponse> processPayment(
            @RequestBody PaymentProcessRequest request,
            @RequestParam(required = false) String webhookUrl) {
        
        // 결제 검증 (동기식)
        if (!paymentService.validatePaymentRequest(request)) {
            return ResponseEntity.badRequest().body(
                new PaymentResponse(null, "INVALID", "Invalid payment request")
            );
        }
        
        // 결제 ID 생성 및 초기 상태 저장
        String paymentId = UUID.randomUUID().toString();
        Payment payment = new Payment(
            paymentId,
            request.getAuthorizationId(),
            request.getAmount(),
            request.getCurrency(),
            PaymentStatus.PROCESSING,
            webhookUrl
        );
        paymentRepository.save(payment);
        
        // 비동기 결제 처리 시작
        paymentService.processPaymentAsync(paymentId);
        
        // 즉시 응답
        return ResponseEntity
            .accepted()
            .body(new PaymentResponse(
                paymentId,
                "PROCESSING",
                "Payment is being processed"
            ));
    }
    
    // 결제 상태 조회 (동기식)
    @GetMapping("/{paymentId}")
    public ResponseEntity<PaymentStatusResponse> getPaymentStatus(
            @PathVariable String paymentId) {
        
        Payment payment = paymentRepository.findById(paymentId)
            .orElseThrow(() -> new ResourceNotFoundException("Payment not found"));
        
        return ResponseEntity.ok(new PaymentStatusResponse(
            payment.getId(),
            payment.getStatus().toString(),
            payment.getStatusMessage(),
            payment.getCompletedAt(),
            payment.getTransactionReference()
        ));
    }
}

@Service
public class PaymentService {

    private final PaymentRepository paymentRepository;
    private final PaymentGateway paymentGateway;
    private final WebhookService webhookService;
    private final TaskExecutor taskExecutor;
    
    // 비동기 결제 처리
    public void processPaymentAsync(String paymentId) {
        taskExecutor.execute(() -> {
            try {
                Payment payment = paymentRepository.findById(paymentId).orElse(null);
                if (payment == null) return;
                
                // 결제 게이트웨이 호출
                PaymentResult result = paymentGateway.processPayment(
                    payment.getAuthorizationId(),
                    payment.getAmount(),
                    payment.getCurrency()
                );
                
                // 결과 저장
                payment.setStatus(result.isSuccessful() ? 
                    PaymentStatus.COMPLETED : PaymentStatus.FAILED);
                payment.setStatusMessage(result.getMessage());
                payment.setTransactionReference(result.getTransactionId());
                payment.setCompletedAt(LocalDateTime.now());
                paymentRepository.save(payment);
                
                // 웹훅 알림 전송 (있는 경우)
                if (payment.getWebhookUrl() != null) {
                    webhookService.sendPaymentWebhook(payment);
                }
            } catch (Exception e) {
                // 오류 처리 및 저장
                Payment payment = paymentRepository.findById(paymentId).orElse(null);
                if (payment != null) {
                    payment.setStatus(PaymentStatus.ERROR);
                    payment.setStatusMessage("Processing error: " + e.getMessage());
                    paymentRepository.save(payment);
                }
                
                // 로깅
                log.error("Payment processing failed: {}", e.getMessage(), e);
            }
        });
    }
    
    // 다른 메서드들…
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// Spring WebFlux를 사용한 반응형 API 예시
@RestController
@RequestMapping("/api/v1/products")
public class ProductController {

    private final ProductRepository productRepository;
    
    @GetMapping
    public Flux<Product> getAllProducts() {
        return productRepository.findAll();
    }
    
    @GetMapping("/{id}")
    public Mono<ResponseEntity<Product>> getProductById(@PathVariable String id) {
        return productRepository.findById(id)
            .map(product -> ResponseEntity.ok(product))
            .defaultIfEmpty(ResponseEntity.notFound().build());
    }
    
    @PostMapping
    public Mono<ResponseEntity<Product>> createProduct(@RequestBody Mono<Product> productMono) {
        return productMono
            .flatMap(productRepository::save)
            .map(savedProduct -> 
                ResponseEntity
                    .created(URI.create("/api/v1/products/" + savedProduct.getId()))
                    .body(savedProduct)
            );
    }
    
    @GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<ProductEvent> streamProductEvents() {
        return Flux.interval(Duration.ofSeconds(1))
            .map(sequence -> new ProductEvent(sequence, "Product Event"));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// GraphQL 스키마 정의 예시
type Query {
  product(id: ID!): Product
  products(category: String, limit: Int): [Product]
}

type Mutation {
  createProduct(input: ProductInput!): Product
  updateProduct(id: ID!, input: ProductInput!): Product
  deleteProduct(id: ID!): Boolean
}

type Subscription {
  productUpdated: Product
  newProductInCategory(category: String!): Product
}

type Product {
  id: ID!
  name: String!
  description: String
  price: Float!
  category: String
  inStock: Boolean
}

input ProductInput {
  name: String!
  description: String
  price: Float!
  category: String
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Spring GraphQL을 사용한 리졸버 구현 예시
@Component
public class ProductResolver {

    private final ProductService productService;
    private final ReactiveStreamsPublisher<Product> productPublisher;
    
    // 쿼리 리졸버 (동기식)
    @QueryMapping
    public Product product(@Argument String id) {
        return productService.getProductById(id);
    }
    
    @QueryMapping
    public List<Product> products(
            @Argument String category,
            @Argument Integer limit) {
        return productService.findProducts(category, limit);
    }
    
    // 뮤테이션 리졸버 (비동기식으로도 구현 가능)
    @MutationMapping
    public Mono<Product> createProduct(@Argument ProductInput input) {
        return productService.createProductAsync(input);
    }
    
    // 구독 리졸버 (비동기식)
    @SubscriptionMapping
    public Publisher<Product> productUpdated() {
        return productPublisher;
    }
    
    @SubscriptionMapping
    public Publisher<Product> newProductInCategory(@Argument String category) {
        return productPublisher
            .filter(product -> category.equals(product.getCategory()));
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

// AWS Lambda와 API Gateway를 사용한 서버리스 비동기 API 예시
// Lambda 함수 (API 엔드포인트)
exports.initiateProcessing = async (event) => {
  const requestBody = JSON.parse(event.body);
  const jobId = uuidv4();
  
  // DynamoDB에 작업 메타데이터 저장
  await dynamoDb.put({
    TableName: 'Jobs',
    Item: {
      jobId,
      status: 'PROCESSING',
      input: requestBody,
      createdAt: new Date().toISOString()
    }
  }).promise();
  
  // SQS에 처리 작업 메시지 전송
  await sqs.sendMessage({
    QueueUrl: process.env.PROCESSING_QUEUE_URL,
    MessageBody: JSON.stringify({
      jobId,
      payload: requestBody
    })
  }).promise();
  
  // 즉시 응답
  return {
    statusCode: 202,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jobId,
      status: 'PROCESSING',
      statusUrl: `/jobs/${jobId}`
    })
  };
};

// 작업 처리 Lambda 함수 (SQS 트리거)
exports.processJob = async (event) => {
  for (const record of event.Records) {
    const { jobId, payload } = JSON.parse(record.body);
    
    try {
      // 실제 처리 로직
      const result = await processData(payload);
      
      // 처리 결과 저장
      await dynamoDb.update({
        TableName: 'Jobs',
        Key: { jobId },
        UpdateExpression: 'SET #status = :status, result = :result, completedAt = :completedAt',
        ExpressionAttributeNames: { '#status': 'status' },
        ExpressionAttributeValues: {
          ':status': 'COMPLETED',
          ':result': result,
          ':completedAt': new Date().toISOString()
        }
      }).promise();
      
      // 선택적: SNS 토픽으로 완료 알림 전송
      await sns.publish({
        TopicArn: process.env.JOB_COMPLETION_TOPIC,
        Message: JSON.stringify({
          jobId,
          status: 'COMPLETED',
          completedAt: new Date().toISOString()
        })
      }).promise();
    } catch (error) {
      // 오류 처리 및 저장
      await dynamoDb.update({
        TableName: 'Jobs',
        Key: { jobId },
        UpdateExpression: 'SET #status = :status, errorMessage = :error, updatedAt = :updatedAt',
        ExpressionAttributeNames: { '#status': 'status' },
        ExpressionAttributeValues: {
          ':status': 'FAILED',
          ':error': error.message,
          ':updatedAt': new Date().toISOString()
        }
      }).promise();
    }
  }
};

// 작업 상태 확인 Lambda 함수
exports.getJobStatus = async (event) => {
  const jobId = event.pathParameters.jobId;
  
  const result = await dynamoDb.get({
    TableName: 'Jobs',
    Key: { jobId }
  }).promise();
  
  if (!result.Item) {
    return {
      statusCode: 404,
      body: JSON.stringify({ error: 'Job not found' })
    };
  }
  
  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(result.Item)
  };
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

// Spring Cloud Stream을 사용한 이벤트 기반 마이크로서비스 예시
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {

    private final OrderService orderService;
    private final StreamBridge streamBridge;
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody OrderRequest request) {
        // 주문 생성
        Order order = orderService.createOrder(request);
        
        // 주문 생성 이벤트 발행
        OrderCreatedEvent event = new OrderCreatedEvent(
            order.getId(),
            order.getCustomerId(),
            order.getItems(),
            order.getTotalAmount(),
            LocalDateTime.now()
        );
        
        streamBridge.send("orderCreatedChannel", event);
        
        // 응답 반환
        return ResponseEntity
            .created(URI.create("/api/v1/orders/" + order.getId()))
            .body(new OrderResponse(order.getId(), "CREATED"));
    }
}

// 이벤트 소비자 서비스
@Configuration
public class OrderEventConsumer {

    private final InventoryService inventoryService;
    
    @Bean
    public Consumer<OrderCreatedEvent> processOrderCreated() {
        return event -> {
            log.info("Received order created event: {}", event.getOrderId());
            
            // 재고 확인 및 할당
            try {
                inventoryService.allocateInventory(event.getOrderId(), event.getItems());
                log.info("Inventory allocated for order: {}", event.getOrderId());
            } catch (Exception e) {
                log.error("Failed to allocate inventory for order {}: {}", 
                    event.getOrderId(), e.getMessage());
                // 보상 트랜잭션 또는 오류 처리 로직
            }
        };
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44