RetryTemplate

RetryTemplate은 Spring Retry의 핵심 컴포턴트로, 일시적인 오류가 발생할 수 있는 작업에 재시도 로직을 쉽게 추가할 수 있게 해준다. 특히 외부 시스템과의 통신, DB 작업, 분산 시스템 등에서 발생할 수 있는 일시적인 실패를 처리하는 데 유용한 것으로 알려져있다.

일반적으로 RetryTemplate을 직접 사용하면 충분하기 때문에 RetryOperations를 직접 구현할 필요는 없다고 한다. 하지만 커스텀이 필요한 경우 인터페이스를 직접 활용할 수 있다.

• RetryTemplate = RetryOperations의 구현체

구성

RetryTemplate은 다음과 같이 구성된다.

1. 실행할 작업을 정의(RetryCallback) (예: 외부 API 호출, DB 접근 등)

1. 재시도 정책(Retry Policy) 설정

재시도 여부와 횟수를 결정한다.

• 최대 재시도 횟수

• 재시도할 예외 유형 지정

// 주요 구현체
SimpleRetryPoilcy: 지정된 최대 시도 횟수까지 재시도
TimeoutRetryPolicy: 지정된 시간 동안 재시도
ExceptionClassifierRetryPolicy: 예외 유형에 따라 다른 정책 적용
CircuitBreakerRetryPolicy: 서킷 브레이커 패턴 구현

1. 대기 전략(Backoff Policy) 설정

재시도 사이의 대기 시간을 결정한다.

• 일정 시간 간격으로 재시도

• 점진적(Exponential) 증가 방식 지원

// 주요 구현체
FixedBackOffPolicy: 항상 일정한 시간만큼 대기
ExponentialBackOffPolicy: 지수적으로 증가하는 대기 시간 적용
ExponentialRandomBackOffPolicy: 지수적으로 증가하는 대기 시간에 무작위성 추가
UniformRandomBackOffPolicy: 지정된 범위 내에서 무작위 대기 시간 적용

1. 재시도 종료 후 대체 처리(Fallback) 가능

모든 재시도가 실패한 후에 수행할 복구 작업을 정의한다.

Backoff(재시도 간격) 정책

FixedBackOffPolicy (고정 시간 간격)

FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
backOffPolicy.setBackOffPeriod(3000); // 3초마다 재시도

ExponentialBackOffPolicy (점진적 증가)

ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
backOffPolicy.setInitialInterval(1000); // 최초 1초
backOffPolicy.setMultiplier(2.0); // 2배씩 증가
backOffPolicy.setMaxInterval(10000); // 최대 10초

RandomBackOffPolicy (랜덤 간격)

RandomBackOffPolicy backOffPolicy = new RandomBackOffPolicy();
backOffPolicy.setMinBackOffPeriod(1000); // 최소 1초
backOffPolicy.setMaxBackOffPeriod(5000); // 최대 5초

Spring에서의 사용

1. RetryTemplate Bean 구성

@Configuration
@EnableRetry
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        
        // 최대 3번 재시도 정책 설정
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        
        // 고정 1초 대기 시간 설정
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(1000); // 1초
        
        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);
        
        return retryTemplate;
    }
}

2. RetryTemplate을 직접 정의해서 사용

public ApiResponse callExternalService(String request) {
    return retryTemplate.execute(
        // RetryCallback - 재시도할 작업
        context -> {
            return externalApi.callService(request);
        },
        // RecoveryCallback - 모든 재시도 실패 후 실행
        context -> {
            // 실패 정보 가져오기
            Throwable lastThrowable = context.getLastThrowable();
            
            // 기본값 반환 또는 대체 작업 수행
            return new ApiResponse("FAILED", "Service temporarily unavailable");
        }
    );
}

3. 어노테이션 기반 사용

@Configuration
@EnableRetry
public class RetryConfig {
    // @EnableRetry 어노테이션으로 활성화
}

@Service
public class ExternalServiceClient {
    
    private final ExternalApi externalApi;
    
    @Retryable(
        value = {ServiceTemporaryException.class}, // 재시도할 예외 유형
        maxAttempts = 3,                         // 최대 시도 횟수
        backoff = @Backoff(delay = 1000, multiplier = 2) // 1초 대기 후 2배씩 증가
    )
    public ApiResponse callExternalService(String request) {
        return externalApi.callService(request);
    }
    
    @Recover
    public ApiResponse recoverFromFailure(ServiceTemporaryException e, String request) {
        // 모든 재시도 실패 후 호출되는 복구 메서드
        return new ApiResponse("FAILED", "Service temporarily unavailable");
    }
}

아래부터는 조금 커스텀한 설정

4. ExponentialBackOffPolicy 예제

@Bean
public RetryTemplate retryTemplateWithExponentialBackoff() {
    RetryTemplate template = new RetryTemplate();
    
    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(500);   // 초기 대기 시간: 500ms
    backOffPolicy.setMultiplier(2.0);        // 배수: 각 재시도마다 2배씩 증가
    backOffPolicy.setMaxInterval(10000);     // 최대 대기 시간: 10초
    
    template.setBackOffPolicy(backOffPolicy);
    
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
    retryPolicy.setMaxAttempts(5);
    template.setRetryPolicy(retryPolicy);
    
    return template;
}

5. 특정 예외에 대해서만 재시도

@Bean
public RetryTemplate retryTemplateForSpecificExceptions() {
    RetryTemplate template = new RetryTemplate();
    
    // 특정 예외 유형에 대해서만 재시도 정책 설정
    Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
    retryableExceptions.put(SocketTimeoutException.class, true);
    retryableExceptions.put(ConnectException.class, true);
    retryableExceptions.put(ResourceAccessException.class, true);
    // IllegalArgumentException은 재시도하지 않음 
    retryableExceptions.put(IllegalArgumentException.class, false);
    
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3, retryableExceptions);
    
    template.setRetryPolicy(retryPolicy);
    
    return template;
}

6. RetryContext 활용

retryTemplate.execute(
    context -> {
        // 현재 재시도 횟수 확인
        int retryCount = context.getRetryCount();
        log.info("Attempt {} for operation", retryCount + 1);
        
        // 이전 예외 확인
        Throwable lastException = context.getLastThrowable();
        if (lastException != null) {
            log.warn("Previous attempt failed with: {}", lastException.getMessage());
        }
        
        // 컨텍스트에 상태 저장
        context.setAttribute("timestamp", System.currentTimeMillis());
        
        return externalService.callApi();
    },
    context -> {
        // 재시도 횟수 확인
        int retryCount = context.getRetryCount();
        log.error("All {} retry attempts failed", retryCount);
        
        // 저장된 상태 확인
        Long timestamp = (Long) context.getAttribute("timestamp");
        
        return fallbackMethod();
    }
);

7. CircuitBreakerRetryPolicy 설정

@Bean
public RetryTemplate retryTemplateWithCircuitBreaker() {
    RetryTemplate template = new RetryTemplate();
    
    // 서킷 브레이커 정책
    CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(3));
    retryPolicy.setOpenTimeout(5000);       // 서킷이 열려있는 시간(ms)
    retryPolicy.setResetTimeout(10000);     // 서킷 상태 리셋 시간(ms)
    
    template.setRetryPolicy(retryPolicy);
    
    return template;
}

8. 데이터베이스 트랜잭션 재시도

@Service
public class UserService {

    private final RetryTemplate retryTemplate;
    private final TransactionTemplate transactionTemplate;
    private final UserRepository userRepository;
    
    // 생성자 주입...
    
    public void updateUserWithRetry(Long userId, String newName) {
        retryTemplate.execute(context -> 
            transactionTemplate.execute(status -> {
                User user = userRepository.findById(userId)
                    .orElseThrow(() -> new NotFoundUserException(userId));
                user.setName(newName);
                return userRepository.save(user);
            })
        );
    }
}

9. 외부 API 호출 재시도

@Service
public class ExternalService {

    private final RetryTemplate retryTemplate;
    private final RestTemplate restTemplate;
    
    public WeatherData getWeatherData(String city) {
        return retryTemplate.execute(
            context -> {
                String url = "<https://api.weather.com/data?city=>" + city;
                return restTemplate.getForObject(url, WeatherData.class);
            },
            context -> {
                // 모든 재시도 실패시 기본 날씨 데이터 반환
                log.error("Failed to get weather data for {}", city);
                return new WeatherData(city, "Unknown", 0.0);
            }
        );
    }
}

재시도 전략을 잘 활용하면 시스템의 안정성이나 데이터의 멱등성을 보장할 수 있겠지만 주의해야 할 부분도 있을 것 같다.

• 모든 예외에 재시도를 시도하는 것이 아닌 대상을 식별해야 한다. (네트워크 문제, 일시적 서비스 장애 등)

• 재시도 횟수 제한의 필요성 (같은 이유로 실패하는 로직이 계속 재시도를 한다면..? 설정하는 큰 의미가 없을 것 같다.)

• 모든 재시도가 실패하면 RecoveryCallback(복구 전략)을 잘 구현하자.

• 트랜잭션 내에서 재시도를 한다면, 전파 흐름을 명확하게 이해하자.