🚀 Spring @Retryable로 오류 복구 마스터하기! 🛠️

안녕하세요, 개발자 여러분! 오늘은 정말 꿀잼 주제로 찾아왔어요. 바로 Spring의 @Retryable을 이용한 오류 복구 메커니즘 구현에 대해 알아볼 거예요. 이거 진짜 개발자들 사이에서 핫한 주제라고요! 🔥 재능넷에서도 이런 스킬 가진 개발자들 모시러 난리 났다던데? ㅋㅋㅋ

🤔 @Retryable이 뭐길래 이렇게 난리야?

자, 여러분. 개발하다 보면 진짜 짜증나는 게 뭐게요? 바로 에러죠! 특히 네트워크 문제나 일시적인 서버 다운 같은 거 때문에 생기는 에러는 정말... 🤦‍♂️ 근데 @Retryable을 쓰면 이런 문제를 엄청 쉽게 해결할 수 있어요!

@Retryable은 Spring의 어노테이션 중 하나예요. 이걸 메서드 위에 붙이면, 그 메서드가 실패했을 때 자동으로 재시도를 해줘요. 완전 개꿀 기능이죠? ㅋㅋㅋ

위 그림을 보세요. 에러가 발생하면 @Retryable이 "잠깐만, 내가 다시 한 번 해볼게!"라고 하면서 재시도를 하는 거예요. 완전 든든한 친구 같죠? 😎

🛠️ @Retryable 사용법, 어렵지 않아요!

자, 이제 실제로 어떻게 사용하는지 알아볼까요? 먼저, Spring Boot 프로젝트에 spring-retry 의존성을 추가해야 해요.

implementation 'org.springframework.retry:spring-retry'
implementation 'org.springframework.boot:spring-boot-starter-aop'
  

이렇게 의존성을 추가하고 나면, 이제 @Retryable을 사용할 준비가 된 거예요! 👍

그 다음, 재시도하고 싶은 메서드 위에 @Retryable 어노테이션을 붙여주면 돼요. 예를 들어볼까요?

import org.springframework.retry.annotation.Retryable;

@Service
public class MyService {

    @Retryable(value = RuntimeException.class, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public void doSomethingRisky() {
        // 위험한 작업 수행
    }
}
  

우와, 이게 뭔가 싶죠? 하나씩 설명해 드릴게요!

• value = RuntimeException.class: 이건 어떤 예외가 발생했을 때 재시도할 건지 지정하는 거예요. 여기서는 RuntimeException이 발생하면 재시도한다는 뜻이에요.
• maxAttempts = 3: 최대 몇 번까지 재시도할 건지 정하는 거예요. 여기서는 3번이네요.
• backoff = @Backoff(delay = 1000): 재시도 사이에 얼마나 기다릴지 정하는 거예요. 1000은 1초를 의미해요.

이렇게 설정하면, doSomethingRisky() 메서드가 RuntimeException을 던졌을 때, Spring은 최대 3번까지 1초 간격으로 재시도를 할 거예요. 완전 똑똑하죠? 👨‍🔬

🎭 @Recover: @Retryable의 든든한 백업

@Retryable만으로 부족하다고요? 걱정 마세요! Spring은 @Recover라는 또 다른 꿀 기능을 제공해요. 이건 뭐냐고요? @Retryable로 지정한 최대 재시도 횟수를 넘어서도 실패하면 실행되는 메서드를 지정하는 거예요.

@Service
public class MyService {

    @Retryable(value = RuntimeException.class, maxAttempts = 3)
    public void doSomethingRisky() {
        // 위험한 작업 수행
    }

    @Recover
    public void recover(RuntimeException e) {
        // 모든 재시도가 실패했을 때 실행될 로직
        System.out.println("모든 재시도 실패! 대체 로직 실행");
    }
}
  

이렇게 하면, doSomethingRisky() 메서드가 3번 실패하면 recover() 메서드가 실행돼요. 완벽한 백업 플랜이죠? 👏

이 그림을 보세요. @Retryable이 세 번 시도하고 실패하면, 마지막에 @Recover가 등장해서 상황을 수습하는 거예요. 완전 히어로 같지 않나요? 🦸‍♂️

🧪 실전 예제: 외부 API 호출

자, 이제 실제로 어떻게 사용하는지 예제를 통해 알아볼까요? 가장 흔한 사용 사례 중 하나는 외부 API를 호출할 때예요. 네트워크 문제로 API 호출이 실패할 수 있잖아요? 이럴 때 @Retryable을 사용하면 아주 좋아요!

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class WeatherService {

    private final RestTemplate restTemplate;

    public WeatherService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Retryable(value = RuntimeException.class, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public String getWeather(String city) {
        String url = "https://api.weather.com/v1/current?city=" + city;
        return restTemplate.getForObject(url, String.class);
    }

    @Recover
    public String recoverGetWeather(RuntimeException e, String city) {
        return "날씨 정보를 가져오는데 실패했습니다. 도시: " + city;
    }
}
  

이 예제에서는 날씨 API를 호출하는 getWeather() 메서드에 @Retryable을 적용했어요. 만약 API 호출이 실패하면, Spring은 최대 3번까지 1초 간격으로 재시도를 할 거예요. 그래도 실패하면? 그때는 recoverGetWeather() 메서드가 실행되어 기본 메시지를 반환하게 돼요.

이렇게 하면 일시적인 네트워크 문제 때문에 사용자가 에러를 보는 일을 크게 줄일 수 있어요. 완전 개발자의 품격 아니겠어요? 😎

🎛️ @Retryable 고급 설정

지금까지 기본적인 사용법을 알아봤는데요, @Retryable은 더 다양한 옵션을 제공해요. 이걸 잘 활용하면 더욱 섬세한 재시도 전략을 구현할 수 있답니다!

• include: 재시도할 예외 타입을 지정해요. 여러 개를 지정할 수도 있어요.
• exclude: 재시도하지 않을 예외 타입을 지정해요.
• backoff: 재시도 간격을 더 세밀하게 조정할 수 있어요.

예를 들어볼까요?

@Retryable(
    include = {SocketTimeoutException.class, ResourceAccessException.class},
    exclude = {NullPointerException.class},
    maxAttempts = 5,
    backoff = @Backoff(delay = 1000, multiplier = 2)
)
public void complexOperation() {
    // 복잡한 작업 수행
}
  

이 설정은 뭘 의미하는 걸까요?

1. SocketTimeoutException이나 ResourceAccessException이 발생하면 재시도를 해요.
2. 하지만 NullPointerException이 발생하면 재시도하지 않아요.
3. 최대 5번까지 재시도해요.
4. 첫 번째 재시도는 1초 후에, 그 다음부터는 간격이 2배씩 늘어나요. (1초, 2초, 4초, 8초...)

이렇게 하면 네트워크 관련 문제는 재시도하지만, 코드의 논리적 오류(NullPointerException 같은)는 바로 실패 처리할 수 있어요. 똑똑하죠? 🧠

이 그림을 보세요. 재시도 간격이 어떻게 늘어나는지 한눈에 보이죠? 이렇게 하면 초기에는 빠르게 재시도하다가, 문제가 지속되면 점점 더 긴 간격을 두고 재시도하게 돼요. 서버에 과부하를 주지 않으면서도 효과적으로 재시도할 수 있는 방법이에요! 👌

🏗️ @Retryable 활용 아키텍처

@Retryable을 사용할 때는 전체 애플리케이션 아키텍처를 고려해야 해요. 어떻게 구성하면 좋을까요?

1. 서비스 계층에 적용: 보통 @Retryable은 서비스 계층의 메서드에 적용해요. 이렇게 하면 비즈니스 로직과 재시도 로직을 깔끔하게 분리할 수 있어요.
2. AOP 활용: @Retryable은 내부적으로 AOP(Aspect-Oriented Programming)를 사용해요. 이를 잘 활용하면 코드 중복을 줄이고 관심사를 분리할 수 있어요.
3. 로깅 전략: 재시도가 발생할 때마다 로그를 남기는 것이 좋아요. 이렇게 하면 나중에 문제를 분석하기 쉬워져요.
4. 모니터링 연동: 재시도 횟수나 실패율 등을 모니터링 시스템과 연동하면, 시스템의 건강 상태를 실시간으로 확인할 수 있어요.

이런 구조로 설계하면 어떤 장점이 있을까요?

• 코드의 가독성이 높아져요.
• 유지보수가 쉬워져요.
• 시스템의 안정성이 향상돼요.
• 문제 상황을 빠르게 파악하고 대응할 수 있어요.

완전 개발자의 꿈이죠? 😍

🧩 @Retryable과 다른 Spring 기능들의 조합

@Retryable은 혼자서도 강력하지만, 다른 Spring 기능들과 조합하면 더욱 빛을 발해요. 어떤 조합이 가능할까요?

1. @Transactional과의 조합

@Retryable을 @Transactional과 함께 사용할 때는 주의가 필요해요. 왜냐고요? @Transactional은 메서드 실행이 끝날 때 트랜잭션을 커밋하거나 롤백하는데, @Retryable로 인해 메서드가 여러 번 실행되면 예상치 못한 결과가 발생할 수 있거든요.

@Service
public class PaymentService {

    @Transactional
    @Retryable(maxAttempts = 3)
    public void processPayment(Payment payment) {
        // 결제 처리 로직
    }
}
  

이런 경우, 각 재시도마다 새로운 트랜잭션이 시작돼요. 그래서 이전 시도의 데이터베이스 변경사항이 롤백되지 않을 수 있어요. 주의해서 사용해야 해요!

2. @Async와의 조합

@Retryable을 @Async와 함께 사용하면 비동기적으로 재시도를 수행할 수 있어요. 이렇게 하면 메인 스레드를 블로킹하지 않고 재시도를 할 수 있죠.

@Service
public class EmailService {

    @Async
    @Retryable(maxAttempts = 3)
    public CompletableFuture<void> sendEmail(String to, String subject, String body) {
        // 이메일 전송 로직
        return CompletableFuture.completedFuture(null);
    }
}
  </void>

이 방식은 특히 외부 서비스 호출 같은 시간이 오래 걸리는 작업에 유용해요. 사용자 경험을 해치지 않으면서도 안정성을 높일 수 있거든요!

3. Spring Cloud Circuit Breaker와의 조합

@Retryable을 Spring Cloud Circuit Breaker와 함께 사용하면 더욱 강력한 오류 처리 메커니즘을 구축할 수 있어요. Circuit Breaker는 일정 수준 이상의 오류가 발생하면 서비스 호출을 일시적으로 차단해서 시스템을 보호하는 역할을 해요.

@Service
public class ResillientService {

    @CircuitBreaker(name = "myService", fallbackMethod = "fallback")
    @Retryable(maxAttempts = 3)
    public String callExternalService() {
        // 외부 서비스 호출 로직
    }

    public String fallback(Exception e) {
        return "외부 서비스 호출 실패. 기본값 반환.";
    }
}
  

이렇게 하면 재시도 후에도 서비스가 정상화되지 않으면 Circuit Breaker가 작동해서 시스템을 보호해요. 완전 철벽 방어 아니에요? 💪

이 그림을 보세요. @Retryable이 여러 번 시도하고 실패하면, Circuit Breaker가 작동해서 시스템을 보호하는 모습이 보이시나요? 이렇게 여러 기술을 조합하면 더욱 강력한 오류 처리 시스템을 만들 수 있어요!

🚦 @Retryable 사용 시 주의사항

@Retryable은 정말 유용한 기능이지만, 사용할 때 주의해야 할 점들이 있어요. 어떤 것들이 있는지 알아볼까요?

1. 멱등성 확인: 재시도하는 메서드가 멱등성을 가지는지 꼭 확인해야 해요. 멱등성이란 동일한 요청을 여러 번 보내도 결과가 같은 성질을 말해요. 예를 들어, 결제 처리 같은 경우 재시도로 인해 중복 결제가 발생하면 안 되겠죠?
2. 재시도 간격 설정: 재시도 간격을 너무 짧게 설정하면 시스템에 불필요한 부하를 줄 수 있어요. 반대로 너무 길게 설정하면 사용자 경험이 나빠질 수 있죠. 적절한 균형을 찾는 게 중요해요.
3. 무한 재시도 방지: maxAttempts를 설정하지 않으면 무한히 재시도할 수 있어요. 이는 시스템 리소스를 과도하게 사용할 수 있으므로 주의가 필요해요.
4. 예외 처리 주의: 모든 예외에 대해 재시도하는 것은 좋지 않아요. 일시적인 문제로 인한 예외만 재시도하도록 설정하는 것이 좋습니다.
5. 로깅과 모니터링: 재시도 횟수와 결과를 반드시 로깅하고 모니터링해야 해요. 이를 통해 시스템의 문제를 조기에 발견하고 대응할 수 있어요.

🌟 @Retryable 실전 활용 팁

자, 이제 @Retryable을 실전에서 더욱 효과적으로 활용할 수 있는 팁들을 알아볼까요?

1. 재시도 정책 커스터마이징

Spring Retry는 기본적인 재시도 정책 외에도 다양한 커스텀 정책을 만들 수 있어요. 예를 들어, 지수 백오프(Exponential Backoff) 정책을 구현해볼까요?

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000);
        backOffPolicy.setMultiplier(2);
        backOffPolicy.setMaxInterval(30000);
        
        retryTemplate.setBackOffPolicy(backOffPolicy);
        
        return retryTemplate;
    }
}
  

이렇게 설정하면 재시도 간격이 1초, 2초, 4초, 8초... 이렇게 늘어나다가 최대 30초까지 증가해요. 네트워크 지연이 심한 환경에서 특히 유용하답니다!

2. 조건부 재시도

때로는 특정 조건에서만 재시도를 하고 싶을 수 있어요. 이럴 때는 RetryTemplate과 함께 RetryCallback을 사용할 수 있어요.

@Service
public class ConditionalRetryService {

    private final RetryTemplate retryTemplate;

    public ConditionalRetryService(RetryTemplate retryTemplate) {
        this.retryTemplate = retryTemplate;
    }

    public String conditionalRetry() {
        return retryTemplate.execute(context -> {
            // 여기에 재시도할 로직을 작성해요
            if (someCondition()) {
                throw new RetryableException("재시도 필요!");
            }
            return "성공!";
        }, context -> {
            // 모든 재시도가 실패했을 때의 로직
            return "최종 실패";
        });
    }
}
  

이 방식을 사용하면 훨씬 더 세밀한 제어가 가능해져요. 완전 프로 개발자 스타일이죠? 😎

3. 재시도 상태 관리

재시도 과정에서 상태를 유지하고 싶을 때가 있어요. 이럴 때는 RetryContext를 활용할 수 있어요.