Spring에서 멱등성 보장 설계 패턴

@PostMapping("/payments")
public PaymentResponse processPayment(@RequestBody PaymentRequest request) {
    // 매번 새로운 결제 생성 — 중복 요청 시 중복 결제 발생
    Payment payment = paymentService.createPayment(request);
    return new PaymentResponse(payment.getId(), payment.getAmount());
}

@Service
@RequiredArgsConstructor
public class IdempotencyService {
    
    private final StringRedisTemplate redisTemplate;
    
    private static final String KEY_PREFIX = "idempotency:";
    private static final Duration EXPIRY = Duration.ofHours(24);
    
    public Optional<String> getCachedResponse(String idempotencyKey) {
        String key = KEY_PREFIX + idempotencyKey;
        String cached = redisTemplate.opsForValue().get(key);
        return Optional.ofNullable(cached);
    }
    
    public void cacheResponse(String idempotencyKey, String responseJson) {
        String key = KEY_PREFIX + idempotencyKey;
        redisTemplate.opsForValue().set(key, responseJson, EXPIRY);
    }
}

@PostMapping("/payments")
public ResponseEntity<PaymentResponse> processPayment(
        @RequestHeader("Idempotency-Key") String idempotencyKey,
        @RequestBody PaymentRequest request) {
    
    // 1. 캐시 조회
    Optional<String> cached = idempotencyService.getCachedResponse(idempotencyKey);
    if (cached.isPresent()) {
        return ResponseEntity.ok(objectMapper.readValue(cached.get(), PaymentResponse.class));
    }
    
    // 2. 실제 처리
    Payment payment = paymentService.createPayment(request);
    PaymentResponse response = new PaymentResponse(payment.getId(), payment.getAmount());
    
    // 3. 응답 캐싱
    idempotencyService.cacheResponse(idempotencyKey, objectMapper.writeValueAsString(response));
    
    return ResponseEntity.ok(response);
}

CREATE TABLE payment (
    id            BIGSERIAL PRIMARY KEY,
    idempotency_key VARCHAR(64) NOT NULL UNIQUE,  -- 중복 방지
    amount        DECIMAL(19, 2) NOT NULL,
    status        VARCHAR(20) NOT NULL,
    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
);
 
CREATE INDEX idx_idempotency_key ON payment(idempotency_key);

@Entity
@Table(
    name = "payment",
    uniqueConstraints = @UniqueConstraint(columnNames = "idempotency_key")
)
public class Payment {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "idempotency_key", nullable = false, unique = true, length = 64)
    private String idempotencyKey;
    
    @Column(nullable = false, precision = 19, scale = 2)
    private BigDecimal amount;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 20)
    private PaymentStatus status;
    
    @CreatedDate
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
}

@Service
@Transactional
@RequiredArgsConstructor
public class PaymentService {
    
    private final PaymentRepository paymentRepository;
    
    public PaymentResponse createPayment(String idempotencyKey, PaymentRequest request) {
        // 1. 기존 처리 확인
        Optional<Payment> existing = paymentRepository.findByIdempotencyKey(idempotencyKey);
        if (existing.isPresent()) {
            return PaymentResponse.from(existing.get());
        }
        
        // 2. 새 결제 생성 (Unique 제약조건이 동시성 보장)
        Payment payment = Payment.builder()
            .idempotencyKey(idempotencyKey)
            .amount(request.getAmount())
            .status(PaymentStatus.PENDING)
            .build();
        
        try {
            paymentRepository.save(payment);
        } catch (DataIntegrityViolationException e) {
            // Race condition 발생 시 재조회
            return PaymentResponse.from(
                paymentRepository.findByIdempotencyKey(idempotencyKey)
                    .orElseThrow(() -> new IllegalStateException("멱등키 처리 실패"))
            );
        }
        
        // 3. 외부 PG 호출 등 후속 처리
        processPgPayment(payment);
        
        return PaymentResponse.from(payment);
    }
}

@Service
@Transactional
@RequiredArgsConstructor
public class HybridIdempotencyService {
    
    private final StringRedisTemplate redisTemplate;
    private final PaymentRepository paymentRepository;
    
    public PaymentResponse processPayment(String idempotencyKey, PaymentRequest request) {
        // Phase 1: Redis 빠른 경로 (99% 케이스)
        String cacheKey = "idempotency:" + idempotencyKey;
        String cached = redisTemplate.opsForValue().get(cacheKey);
        if (cached != null) {
            return objectMapper.readValue(cached, PaymentResponse.class);
        }
        
        // Phase 2: DB 확인 (Redis miss 시)
        Optional<Payment> existing = paymentRepository.findByIdempotencyKey(idempotencyKey);
        if (existing.isPresent()) {
            PaymentResponse response = PaymentResponse.from(existing.get());
            // Redis 재캐싱 (향후 요청 가속화)
            redisTemplate.opsForValue().set(cacheKey, objectMapper.writeValueAsString(response), 
                                            Duration.ofHours(24));
            return response;
        }
        
        // Phase 3: 새 처리 (Unique 제약조건으로 동시성 제어)
        Payment payment = new Payment(idempotencyKey, request.getAmount());
        try {
            paymentRepository.save(payment);
        } catch (DataIntegrityViolationException e) {
            // Race condition — 재귀 호출로 처리된 결과 반환
            return processPayment(idempotencyKey, request);
        }
        
        // 외부 처리
        processPgPayment(payment);
        
        // 응답 캐싱
        PaymentResponse response = PaymentResponse.from(payment);
        redisTemplate.opsForValue().set(cacheKey, objectMapper.writeValueAsString(response), 
                                        Duration.ofHours(24));
        return response;
    }
}