@RabbitListener(queues = "order.queue")
public void processOrder(OrderMessage message) {
    // 외부 API 호출 실패 → 예외 발생
    paymentService.charge(message.getOrderId()); // RuntimeException!
    // → reject → requeue → 다시 consume → 또 예외 → reject → requeue → ...
}

메시지 수신 → 처리 시도 → 예외 발생
    ↓
RetryPolicy 확인 (재시도 가능?)
    ├─ Yes → BackOffPolicy만큼 대기 → 재시도
    └─ No  → MessageRecoverer에 위임
                ├─ RejectAndDontRequeueRecoverer: reject (requeue=false)
                └─ RepublishMessageRecoverer: DLQ로 재발행

spring:
  rabbitmq:
    listener:
      simple:
        retry:
          enabled: true          # 재시도 활성화 (기본값: false)
          max-attempts: 3        # 최대 시도 횟수 (초기 시도 포함)
          initial-interval: 1000 # 첫 재시도까지 대기 시간 (ms)
          multiplier: 2.0        # 백오프 배수
          max-interval: 10000    # 최대 대기 시간 (ms)

@Configuration
public class RabbitRetryConfig {

    @Bean
    public RetryOperationsInterceptor retryInterceptor() {
        return RetryInterceptorBuilder.stateless()
                .retryPolicy(new SimpleRetryPolicy(3)) // 최대 3회 시도
                .backOffPolicy(exponentialBackOff())
                .recoverer(republishRecoverer())        // 재시도 소진 후 DLQ로
                .build();
    }

    private ExponentialBackOffPolicy exponentialBackOff() {
        ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
        policy.setInitialInterval(1000);  // 첫 대기: 1초
        policy.setMultiplier(2.0);        // 배수: 2배씩 증가
        policy.setMaxInterval(10000);     // 최대 대기: 10초
        return policy;
    }

    @Bean
    public RepublishMessageRecoverer republishRecoverer() {
        // 재시도 소진 후 DLQ exchange로 재발행
        return new RepublishMessageRecoverer(
                rabbitTemplate, "dlx.exchange", "dlq.routing-key"
        );
    }

    // RabbitTemplate은 별도 Bean으로 주입
    @Autowired
    private RabbitTemplate rabbitTemplate;
}

// 메시지를 reject하고 requeue하지 않음
// DLX가 설정되어 있으면 DLX로 전달, 없으면 메시지 유실
new RejectAndDontRequeueRecoverer();

// 지정된 Exchange/Queue로 메시지를 재발행
// 에러 정보(스택트레이스, 예외 메시지)를 헤더에 추가
RepublishMessageRecoverer recoverer = new RepublishMessageRecoverer(
        rabbitTemplate, "dlx.exchange", "dlq.routing-key"
);

Producer → Exchange → Queue → Consumer
                                  ↓ (3회 재시도 실패)
                          RepublishMessageRecoverer
                                  ↓
                          DLX Exchange → DLQ
                                          ↓
                                  모니터링 / 알림 / 수동 재처리

@Component
public class DlqProcessor {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * DLQ 메시지를 확인하고 원래 큐로 재전송하는 관리 기능
     * 운영자가 원인을 파악한 뒤 수동으로 호출
     */
    public void retryFromDlq(String dlqName, String originalExchange, String originalRoutingKey) {
        Message message = rabbitTemplate.receive(dlqName);

        if (message != null) {
            // 에러 헤더 제거 후 원래 큐로 재전송
            message.getMessageProperties().getHeaders().remove("x-exception-stacktrace");
            message.getMessageProperties().getHeaders().remove("x-exception-message");

            rabbitTemplate.send(originalExchange, originalRoutingKey, message);
        }
    }
}

@RabbitListener(queues = "order.queue")
public void processOrder(OrderMessage message) {
    String messageId = message.getMessageId(); // UUID 등 고유 식별자

    // 이미 처리된 메시지인지 확인
    if (processedMessageRepository.existsByMessageId(messageId)) {
        log.info("이미 처리된 메시지, 무시: {}", messageId);
        return; // ACK 전송 (정상 처리로 간주)
    }

    // 비즈니스 로직 실행
    orderService.createOrder(message);

    // 처리 이력 저장 (같은 트랜잭션 내에서)
    processedMessageRepository.save(new ProcessedMessage(messageId));
}

@Transactional
public void processPayment(PaymentMessage message) {
    try {
        // orderId에 UNIQUE 제약이 걸려 있으면 중복 insert 시 예외 발생
        paymentRepository.save(new Payment(
                message.getOrderId(),
                message.getAmount()
        ));
    } catch (DataIntegrityViolationException e) {
        // 중복 처리 시도 → 이미 처리됨, 무시
        log.warn("중복 결제 시도 감지, 무시: orderId={}", message.getOrderId());
    }
}

@RabbitListener(queues = "order.queue")
public void processOrder(OrderMessage message) {
    // message.getAmount()가 음수 → 비즈니스 규칙 위반
    // 아무리 재시도해도 이 메시지는 절대 성공할 수 없음
    if (message.getAmount() < 0) {
        throw new IllegalArgumentException("주문 금액은 양수여야 합니다");
    }
}

@Bean
public RetryOperationsInterceptor retryInterceptor() {
    // 재시도할 예외와 하지 않을 예외를 구분
    Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
    retryableExceptions.put(RuntimeException.class, true);               // 재시도 대상
    retryableExceptions.put(IllegalArgumentException.class, false);      // 재시도하지 않음 (데이터 문제)
    retryableExceptions.put(MessageConversionException.class, false);    // 재시도하지 않음 (역직렬화 실패)

    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(3, retryableExceptions, true);

    return RetryInterceptorBuilder.stateless()
            .retryPolicy(retryPolicy)
            .backOffPolicy(exponentialBackOff())
            .recoverer(republishRecoverer())
            .build();
}

@Configuration
public class RabbitErrorHandlingConfig {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    // DLQ 인프라 선언
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("dlx.exchange");
    }

    @Bean
    public Queue dlq() {
        return QueueBuilder.durable("order.dlq")
                .ttl(604800000) // 7일 후 자동 삭제
                .build();
    }

    @Bean
    public Binding dlqBinding() {
        return BindingBuilder.bind(dlq())
                .to(dlxExchange())
                .with("order.dlq.routing-key");
    }

    // 재시도 인터셉터
    @Bean
    public RetryOperationsInterceptor retryInterceptor() {
        return RetryInterceptorBuilder.stateless()
                .retryPolicy(new SimpleRetryPolicy(3))
                .backOffPolicy(exponentialBackOff())
                .recoverer(new RepublishMessageRecoverer(
                        rabbitTemplate, "dlx.exchange", "order.dlq.routing-key"
                ))
                .build();
    }

    private ExponentialBackOffPolicy exponentialBackOff() {
        ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
        policy.setInitialInterval(1000);
        policy.setMultiplier(2.0);
        policy.setMaxInterval(10000);
        return policy;
    }

    // 리스너 컨테이너 팩토리에 재시도 인터셉터 적용
    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
            ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setAdviceChain(retryInterceptor());
        factory.setAcknowledgeMode(AcknowledgeMode.AUTO); // 재시도 소진 후 자동 ACK/NACK
        return factory;
    }
}