[🚀 방탈출 예약 외부 API 연동 3단계] 티뉴 미션 제출합니다.

src/main/java/roomescape/config/WebConfig.java

@@ -1,12 +1,26 @@
 package roomescape.config;
 
 import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import roomescape.ratelimit.RateLimitInterceptor;
 
 @Configuration
 public class WebConfig implements WebMvcConfigurer {
 
+    private final RateLimitInterceptor rateLimitInterceptor;
+
+    public WebConfig(RateLimitInterceptor rateLimitInterceptor) {
+        this.rateLimitInterceptor = rateLimitInterceptor;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(rateLimitInterceptor)
+                .addPathPatterns("/reservations", "/payments/**");
+    }
+
     @Override
     public void addViewControllers(ViewControllerRegistry registry) {
         registry.addViewController("/").setViewName("index");

src/main/java/roomescape/exception/GlobalExceptionHandler.java

@@ -33,6 +33,7 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
     private static final String DETAIL_INTERNAL_ERROR = "요청을 처리하는 중 알 수 없는 오류가 발생했습니다.";
     private static final String DETAIL_PAYMENT_FAILED = "결제 처리 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.";
     private static final String DETAIL_PAYMENT_UNCERTAIN = "결제 승인 결과를 확인하지 못했습니다. 잠시 후 주문 내역에서 결제 상태를 확인해주세요.";
+    private static final String DETAIL_OUTBOUND_RATE_LIMITED = "외부 결제 API 호출 한도를 초과했습니다. 잠시 후 다시 시도해주세요.";
     private static final String ERRORS_PROPERTY = "errors";
     private static final String POINTER_PREFIX = "/";
 
@@ -81,6 +82,16 @@ public ProblemDetail handleTransient(TransientDataAccessException ex, WebRequest
         return buildProblem(HttpStatus.CONFLICT, ProblemType.CONCURRENCY_CONFLICT, DETAIL_TRANSIENT, Level.WARN, ex, request);
     }
 
+    @ExceptionHandler(OutboundRateLimitException.class)
+    public ResponseEntity<ProblemDetail> handleOutboundRateLimit(OutboundRateLimitException ex, WebRequest request) {
+        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.SERVICE_UNAVAILABLE, DETAIL_OUTBOUND_RATE_LIMITED);
+        applyType(problem, ProblemType.OUTBOUND_RATE_LIMITED, request);
+        logException(Level.WARN, ex, HttpStatus.SERVICE_UNAVAILABLE, request);
+        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
+                .header(HttpHeaders.RETRY_AFTER, String.valueOf(ex.retryAfterSeconds()))
+                .body(problem);
+    }
+
     @ExceptionHandler(Exception.class)
     public ProblemDetail handleUnexpected(Exception ex, WebRequest request) {
         return buildProblem(HttpStatus.INTERNAL_SERVER_ERROR, ProblemType.INTERNAL_ERROR, DETAIL_INTERNAL_ERROR, Level.ERROR, ex, request);

src/main/java/roomescape/exception/OutboundRateLimitException.java

@@ -0,0 +1,15 @@
+package roomescape.exception;
+
+public class OutboundRateLimitException extends RoomescapeException {
+
+    private final long retryAfterSeconds;
+
+    public OutboundRateLimitException(long retryAfterSeconds) {
+        super("외부 결제 API 호출 한도를 초과했습니다. retryAfterSeconds=" + retryAfterSeconds);
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+
+    public long retryAfterSeconds() {
+        return retryAfterSeconds;
+    }
+}

src/main/java/roomescape/exception/ProblemType.java

@@ -18,6 +18,7 @@ public enum ProblemType {
     PAYMENT_AMOUNT_MISMATCH("payment-amount-mismatch", "결제 금액 불일치"),
     PAYMENT_FAILED("payment-failed", "결제 실패"),
     PAYMENT_UNCERTAIN("payment-uncertain", "결제 결과 확인 필요"),
+    OUTBOUND_RATE_LIMITED("outbound-rate-limited", "외부 호출 한도 초과"),
     INTERNAL_ERROR("internal-error", "서버 내부 오류");
 
     private static final String TYPE_BASE = "https://roomescape.example/problems/";

src/main/java/roomescape/payment/toss/OutboundRateLimitInterceptor.java

@@ -0,0 +1,28 @@
+package roomescape.payment.toss;
+
+import org.springframework.http.HttpRequest;
+import org.springframework.http.client.ClientHttpRequestExecution;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.http.client.ClientHttpResponse;
+import roomescape.exception.OutboundRateLimitException;
+import roomescape.ratelimit.TokenBucketRateLimiter;
+
+import java.io.IOException;
+
+public class OutboundRateLimitInterceptor implements ClientHttpRequestInterceptor {
+
+    private final TokenBucketRateLimiter rateLimiter;
+
+    public OutboundRateLimitInterceptor(TokenBucketRateLimiter outboundRateLimiter) {
+        this.rateLimiter = outboundRateLimiter;
+    }
+
+    @Override
+    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
+            throws IOException {
+        if (!rateLimiter.tryConsume()) {
+            throw new OutboundRateLimitException(rateLimiter.retryAfterSeconds());
+        }
+        return execution.execute(request, body);
+    }
+}

src/main/java/roomescape/payment/toss/RetryAfterInterceptor.java

@@ -0,0 +1,58 @@
+package roomescape.payment.toss;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpRequest;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.client.ClientHttpRequestExecution;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.http.client.ClientHttpResponse;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Optional;
+
+public class RetryAfterInterceptor implements ClientHttpRequestInterceptor {
+
+    private final int maxAttempts;
+    private final Duration defaultBackoff;
+    private final Sleeper sleeper;
+
+    public RetryAfterInterceptor(int maxAttempts, Duration defaultBackoff, Sleeper sleeper) {
+        if (maxAttempts < 1) {
+            throw new IllegalArgumentException("maxAttempts는 1 이상이어야 합니다. maxAttempts=" + maxAttempts);
+        }
+        this.maxAttempts = maxAttempts;
+        this.defaultBackoff = defaultBackoff;
+        this.sleeper = sleeper;
+    }
+
+    @Override
+    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
+            throws IOException {
+        for (int attempt = 1; ; attempt++) {
+            ClientHttpResponse response = execution.execute(request, body);
+            if (response.getStatusCode().value() != HttpStatus.TOO_MANY_REQUESTS.value()) {
+                return response;
+            }
+            if (attempt >= maxAttempts) {
+                response.close();
+                throw new TossRateLimitException("토스 호출이 요청 한도(429)를 초과했습니다. attempts=" + attempt);
+            }
+            Duration backoff = retryAfter(response).orElse(defaultBackoff);
+            response.close();
+            sleeper.sleep(backoff);
+        }
+    }
+
+    private Optional<Duration> retryAfter(ClientHttpResponse response) throws IOException {
+        String value = response.getHeaders().getFirst(HttpHeaders.RETRY_AFTER);
+        if (value == null || value.isBlank()) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(Duration.ofSeconds(Long.parseLong(value.trim())));
+        } catch (NumberFormatException e) {
+            return Optional.empty();
+        }
+    }
+}

src/main/java/roomescape/payment/toss/Sleeper.java

@@ -0,0 +1,9 @@
+package roomescape.payment.toss;
+
+import java.time.Duration;
+
+@FunctionalInterface
+public interface Sleeper {
+
+    void sleep(Duration duration);
+}

src/main/java/roomescape/payment/toss/ThreadSleeper.java

@@ -0,0 +1,20 @@
+package roomescape.payment.toss;
+
+import java.time.Duration;
+
+public class ThreadSleeper implements Sleeper {
+
+    @Override
+    public void sleep(Duration duration) {
+        long millis = duration.toMillis();
+        if (millis <= 0) {
+            return;
+        }
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IllegalStateException("재시도 대기 중 인터럽트되었습니다.", e);
+        }
+    }
+}

src/main/java/roomescape/payment/toss/TossClientConfig.java

@@ -1,11 +1,13 @@
 package roomescape.payment.toss;
 
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
 import org.springframework.web.client.RestClient;
+import roomescape.ratelimit.TokenBucketRateLimiter;
 
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
@@ -14,12 +16,35 @@
 @Configuration
 public class TossClientConfig {
 
+    @Bean
+    public Sleeper tossBackoffSleeper() {
+        return new ThreadSleeper();
+    }
+
+    @Bean
+    public RetryAfterInterceptor tossRetryAfterInterceptor(
+            @Value("${toss.retry.max-attempts}") int maxAttempts,
+            @Value("${toss.retry.default-backoff}") Duration defaultBackoff,
+            Sleeper tossBackoffSleeper
+    ) {
+        return new RetryAfterInterceptor(maxAttempts, defaultBackoff, tossBackoffSleeper);
+    }
+
+    @Bean
+    public OutboundRateLimitInterceptor tossOutboundRateLimitInterceptor(
+            @Qualifier("outboundRateLimiter") TokenBucketRateLimiter outboundRateLimiter
+    ) {
+        return new OutboundRateLimitInterceptor(outboundRateLimiter);
+    }
+
     @Bean
     public RestClient tossRestClient(
             @Value("${toss.base-url}") String baseUrl,
             @Value("${toss.secret-key}") String secretKey,
             @Value("${toss.connect-timeout}") Duration connectTimeout,
-            @Value("${toss.read-timeout}") Duration readTimeout
+            @Value("${toss.read-timeout}") Duration readTimeout,
+            RetryAfterInterceptor tossRetryAfterInterceptor,
+            OutboundRateLimitInterceptor tossOutboundRateLimitInterceptor
     ) {
         String basic = Base64.getEncoder()
                 .encodeToString((secretKey + ":").getBytes(StandardCharsets.UTF_8));
@@ -32,6 +57,8 @@ public RestClient tossRestClient(
                 .baseUrl(baseUrl)
                 .requestFactory(requestFactory)
                 .defaultHeader(HttpHeaders.AUTHORIZATION, "Basic " + basic)
+                .requestInterceptor(tossRetryAfterInterceptor)
+                .requestInterceptor(tossOutboundRateLimitInterceptor)
                 .build();
     }
 }

src/main/java/roomescape/payment/toss/TossRateLimitException.java

@@ -0,0 +1,8 @@
+package roomescape.payment.toss;
+
+public class TossRateLimitException extends TossPaymentException {
+
+    public TossRateLimitException(String message) {
+        super(message);
+    }
+}

src/main/java/roomescape/ratelimit/RateLimitConfig.java

@@ -0,0 +1,25 @@
+package roomescape.ratelimit;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class RateLimitConfig {
+
+    @Bean
+    public TokenBucketRateLimiter inboundRateLimiter(
+            @Value("${rate-limit.capacity}") long capacity,
+            @Value("${rate-limit.refill-per-sec}") double refillPerSec
+    ) {
+        return new TokenBucketRateLimiter(capacity, refillPerSec, System::nanoTime);
+    }
+
+    @Bean
+    public TokenBucketRateLimiter outboundRateLimiter(
+            @Value("${outbound-rate-limit.capacity}") long capacity,
+            @Value("${outbound-rate-limit.refill-per-sec}") double refillPerSec
+    ) {
+        return new TokenBucketRateLimiter(capacity, refillPerSec, System::nanoTime);
+    }
+}

src/main/java/roomescape/ratelimit/RateLimitInterceptor.java

@@ -0,0 +1,29 @@
+package roomescape.ratelimit;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+@Component
+public class RateLimitInterceptor implements HandlerInterceptor {
+
+    private final TokenBucketRateLimiter rateLimiter;
+
+    public RateLimitInterceptor(@Qualifier("inboundRateLimiter") TokenBucketRateLimiter inboundRateLimiter) {
+        this.rateLimiter = inboundRateLimiter;
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        if (rateLimiter.tryConsume()) {
+            return true;
+        }
+        response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
+        response.setHeader(HttpHeaders.RETRY_AFTER, String.valueOf(rateLimiter.retryAfterSeconds()));
+        return false;
+    }
+}

src/main/java/roomescape/ratelimit/TokenBucketRateLimiter.java

@@ -0,0 +1,58 @@
+package roomescape.ratelimit;
+
+import java.util.function.LongSupplier;
+
+public class TokenBucketRateLimiter {
+
+    private static final double NANOS_PER_SECOND = 1_000_000_000.0;
+
+    private final long capacity;
+    private final double refillPerSec;
+    private final LongSupplier nanoTimeSupplier;
+
+    private double availableTokens;
+    private long lastRefillNanos;
+
+    public TokenBucketRateLimiter(long capacity, double refillPerSec, LongSupplier nanoTimeSupplier) {
+        if (capacity < 1) {
+            throw new IllegalArgumentException("capacity는 1 이상이어야 합니다. capacity=" + capacity);
+        }
+        if (refillPerSec <= 0) {
+            throw new IllegalArgumentException("refillPerSec는 0보다 커야 합니다. refillPerSec=" + refillPerSec);
+        }
+        this.capacity = capacity;
+        this.refillPerSec = refillPerSec;
+        this.nanoTimeSupplier = nanoTimeSupplier;
+        this.availableTokens = capacity;
+        this.lastRefillNanos = nanoTimeSupplier.getAsLong();
+    }
+
+    public synchronized boolean tryConsume() {
+        refill();
+        if (availableTokens >= 1.0) {
+            availableTokens -= 1.0;
+            return true;
+        }
+        return false;
+    }
+
+    public synchronized long retryAfterSeconds() {
+        refill();
+        if (availableTokens >= 1.0) {
+            return 0L;
+        }
+        double shortage = 1.0 - availableTokens;
+        return (long) Math.ceil(shortage / refillPerSec);
+    }
+
+    private void refill() {
+        long now = nanoTimeSupplier.getAsLong();
+        long elapsedNanos = now - lastRefillNanos;
+        if (elapsedNanos <= 0) {
+            return;
+        }
+        double refilled = (elapsedNanos / NANOS_PER_SECOND) * refillPerSec;
+        availableTokens = Math.min(capacity, availableTokens + refilled);
+        lastRefillNanos = now;
+    }
+}

src/main/resources/application.properties

@@ -7,3 +7,12 @@ toss.base-url=https://api.tosspayments.com
 toss.secret-key=test_gsk_docs_OaPz8L5KdmQXkzRz3y47BMw6
 toss.connect-timeout=2s
 toss.read-timeout=5s
+
+rate-limit.capacity=100
+rate-limit.refill-per-sec=50
+
+toss.retry.max-attempts=3
+toss.retry.default-backoff=1s
+
+outbound-rate-limit.capacity=50
+outbound-rate-limit.refill-per-sec=25