Spring Retry — 실패한 작업을 자동으로 재시도하는 전략

// build.gradle
implementation 'org.springframework.retry:spring-retry'
implementation 'org.springframework:spring-aspects'  // AOP 필요

@Configuration
@EnableRetry  // 필수: 재시도 활성화
public class RetryConfig {
}

@Service
@Slf4j
public class PaymentGatewayService {

    @Retryable(
        retryFor = { RestClientException.class, TimeoutException.class },
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000)  // 1초 대기
    )
    public PaymentResult processPayment(PaymentRequest request) {
        log.info("결제 처리 시도: {}", request.getOrderId());
        return paymentApi.charge(request);
        // RestClientException 발생 시 1초 후 재시도
    }

    @Recover  // 모든 재시도 실패 후 호출
    public PaymentResult recover(
            RestClientException e, PaymentRequest request) {
        log.error("결제 처리 최종 실패: {}", request.getOrderId(), e);
        // 폴백: 수동 처리 큐에 등록
        manualProcessQueue.add(request);
        throw new PaymentFailedException("결제 처리에 실패했습니다", e);
    }
}

@Retryable(
    retryFor = Exception.class,
    backoff = @Backoff(delay = 2000)  // 항상 2초 대기
)

@Retryable(
    retryFor = Exception.class,
    maxAttempts = 4,
    backoff = @Backoff(
        delay = 1000,       // 초기 대기: 1초
        multiplier = 2,     // 배수: 2
        maxDelay = 10000    // 최대 대기: 10초
    )
)
// 1초 → 2초 → 4초 → (최대 10초)

@Retryable(
    retryFor = Exception.class,
    backoff = @Backoff(
        delay = 1000,
        multiplier = 2,
        random = true       // 대기 시간에 랜덤 지터 추가
    )
)

@Retryable(
    retryFor = {
        RestClientException.class,  // 네트워크 오류 → 재시도
        TimeoutException.class      // 타임아웃 → 재시도
    },
    noRetryFor = {
        IllegalArgumentException.class,  // 잘못된 파라미터 → 즉시 실패
        AuthenticationException.class    // 인증 오류 → 즉시 실패
    },
    maxAttempts = 3
)
public ApiResponse callExternalApi(ApiRequest request) {
    return externalApiClient.call(request);
}

@Service
public class NotificationService {

    @Retryable(retryFor = MessagingException.class, maxAttempts = 3)
    public void sendEmail(String to, String subject, String body) {
        emailClient.send(to, subject, body);
    }

    // 규칙 1: 반환 타입이 @Retryable 메서드와 같아야 함
    // 규칙 2: 첫 번째 파라미터가 예외 타입
    // 규칙 3: 나머지 파라미터는 @Retryable 메서드와 동일
    @Recover
    public void recoverEmail(
            MessagingException e, String to, String subject, String body) {
        log.error("이메일 발송 실패 [{}]: {}", to, e.getMessage());
        // 대안: SMS로 발송
        smsService.sendFallback(to, "이메일 발송에 실패했습니다");
    }
}

@Recover
public void recoverFromTimeout(
        TimeoutException e, String to, String subject, String body) {
    // 타임아웃 전용 복구 로직
}

@Recover
public void recoverFromMessaging(
        MessagingException e, String to, String subject, String body) {
    // 메시징 오류 전용 복구 로직
}

@Configuration
public class RetryTemplateConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template = new RetryTemplate();

        // 재시도 정책: 최대 3회, 특정 예외만
        Map<Class<? extends Throwable>, Boolean> retryableExceptions =
            new HashMap<>();
        retryableExceptions.put(RestClientException.class, true);
        retryableExceptions.put(TimeoutException.class, true);

        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(
            3, retryableExceptions);
        template.setRetryPolicy(retryPolicy);

        // Backoff 정책: Exponential
        ExponentialBackOffPolicy backOff = new ExponentialBackOffPolicy();
        backOff.setInitialInterval(1000);
        backOff.setMultiplier(2.0);
        backOff.setMaxInterval(10000);
        template.setBackOffPolicy(backOff);

        // 리스너: 재시도 로깅
        template.registerListener(new RetryListenerSupport() {
            @Override
            public <T, E extends Throwable> void onError(
                    RetryContext context, RetryCallback<T, E> callback,
                    Throwable throwable) {
                log.warn("재시도 #{}: {}",
                    context.getRetryCount(), throwable.getMessage());
            }
        });

        return template;
    }
}

@Service
@RequiredArgsConstructor
public class ResilientApiService {
    private final RetryTemplate retryTemplate;

    public ApiResponse callWithRetry(ApiRequest request) {
        return retryTemplate.execute(
            // 재시도 콜백
            context -> {
                log.info("API 호출 시도 #{}", context.getRetryCount() + 1);
                return apiClient.call(request);
            },
            // 복구 콜백 (모든 재시도 실패 시)
            context -> {
                log.error("API 호출 최종 실패");
                return ApiResponse.fallback();
            }
        );
    }
}

@Retryable(
    stateful = true,                   // 상태 유지 재시도
    retryFor = OptimisticLockException.class,
    maxAttempts = 3,
    backoff = @Backoff(delay = 100)
)
@Transactional
public void updateWithOptimisticLock(Long id, String newValue) {
    Entity entity = repository.findById(id).orElseThrow();
    entity.update(newValue);
    // OptimisticLockException 발생 시 트랜잭션 롤백 후 재시도
}

@Service
public class ResilientExternalService {

    // 1차: 재시도로 일시적 오류 대응
    @Retryable(
        retryFor = RestClientException.class,
        maxAttempts = 3,
        backoff = @Backoff(delay = 500, multiplier = 2)
    )
    // 2차: Circuit Breaker로 연쇄 장애 방지
    @CircuitBreaker(name = "externalApi", fallbackMethod = "fallback")
    public ExternalData fetchData(String id) {
        return externalApiClient.getData(id);
    }

    public ExternalData fallback(String id, Exception e) {
        return ExternalData.cached(id);  // 캐시된 데이터 반환
    }
}

@Retryable(retryFor = TimeoutException.class, maxAttempts = 3)
public void processOrder(String orderId) {
    // 멱등성 키로 중복 실행 방지
    if (orderProcessLog.isProcessed(orderId)) {
        log.info("이미 처리된 주문: {}", orderId);
        return;
    }

    orderService.process(orderId);
    orderProcessLog.markAsProcessed(orderId);
}