// BAD: 컨트롤러마다 반복되는 인증 코드 (중복의 지옥)
@GetMapping("/orders")
public ResponseEntity<List<Order>> getOrders(HttpServletRequest request) {
    // 모든 컨트롤러에 이 코드가 반복됨
    String token = request.getHeader("Authorization");
    if (token == null || !tokenService.isValid(token)) {
        return ResponseEntity.status(401).build();
    }
    // 실제 비즈니스 로직
    return ResponseEntity.ok(orderService.findAll());
}

// GOOD: Interceptor로 인증을 한 곳에서 처리
@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        String token = request.getHeader("Authorization");
        if (token == null || !tokenService.isValid(token)) {
            response.setStatus(401);
            return false; // 컨트롤러 진입 차단
        }
        return true;
    }
}

public interface HandlerInterceptor {

    /**
     * 컨트롤러 실행 전 호출
     * @return true: 다음 단계 진행 / false: 처리 중단 (컨트롤러 미호출)
     */
    default boolean preHandle(HttpServletRequest request,
                               HttpServletResponse response,
                               Object handler) throws Exception {
        return true;
    }

    /**
     * 컨트롤러 실행 후, View 렌더링 전 호출
     * 컨트롤러에서 예외 발생 시 호출되지 않음
     */
    default void postHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler,
                             @Nullable ModelAndView modelAndView) throws Exception {
    }

    /**
     * View 렌더링 완료 후 호출 (요청 처리의 가장 마지막 단계)
     * 예외 발생 여부와 관계없이 항상 호출됨 (preHandle이 true를 반환한 경우에만)
     */
    default void afterCompletion(HttpServletRequest request,
                                  HttpServletResponse response,
                                  Object handler,
                                  @Nullable Exception ex) throws Exception {
    }
}

public boolean preHandle(HttpServletRequest request,
                          HttpServletResponse response,
                          Object handler) throws Exception

@Override
public boolean preHandle(HttpServletRequest request,
                          HttpServletResponse response,
                          Object handler) throws Exception {
    // handler를 HandlerMethod로 캐스팅하여 메서드/클래스 어노테이션 확인
    if (handler instanceof HandlerMethod handlerMethod) {
        // 메서드에 붙은 어노테이션 확인
        LoginRequired loginRequired =
            handlerMethod.getMethodAnnotation(LoginRequired.class);

        // 클래스에 붙은 어노테이션 확인
        if (loginRequired == null) {
            loginRequired = handlerMethod.getBeanType()
                .getAnnotation(LoginRequired.class);
        }

        if (loginRequired != null) {
            // 인증이 필요한 경우 처리
            String token = request.getHeader("Authorization");
            if (!isValidToken(token)) {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().write("{\"error\": \"인증이 필요합니다\"}");
                return false; // 처리 중단
            }
        }
    }
    return true; // 계속 진행
}

public void postHandle(HttpServletRequest request,
                        HttpServletResponse response,
                        Object handler,
                        @Nullable ModelAndView modelAndView) throws Exception

@Override
public void postHandle(HttpServletRequest request,
                        HttpServletResponse response,
                        Object handler,
                        ModelAndView modelAndView) throws Exception {
    // REST API라면 modelAndView는 null
    if (modelAndView != null) {
        // 공통 모델 데이터 추가 (예: 메뉴 정보)
        modelAndView.addObject("commonMenus", menuService.getCommonMenus());
    }

    // 응답 헤더 추가
    response.setHeader("X-Processed-By", "MyApp");
}

public void afterCompletion(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler,
                              @Nullable Exception ex) throws Exception

@Override
public void afterCompletion(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler,
                              Exception ex) throws Exception {
    // 요청 처리 시간 로깅
    Long startTime = (Long) request.getAttribute("START_TIME");
    if (startTime != null) {
        long elapsed = System.currentTimeMillis() - startTime;
        log.info("[{}] {} 처리 완료 - {}ms",
            request.getMethod(), request.getRequestURI(), elapsed);
    }

    // 예외 발생 시 추가 로깅
    if (ex != null) {
        log.error("[{}] {} 예외 발생: {}",
            request.getMethod(), request.getRequestURI(), ex.getMessage());
    }

    // ThreadLocal 정리 (메모리 누수 방지!)
    RequestContextHolder.resetRequestAttributes();
}

@Slf4j
@Component
@RequiredArgsConstructor
public class AuthInterceptor implements HandlerInterceptor {

    private final JwtTokenProvider jwtTokenProvider;
    private final UserRepository userRepository;

    private static final String AUTHORIZATION_HEADER = "Authorization";
    private static final String BEARER_PREFIX = "Bearer ";

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) throws Exception {

        // 정적 리소스나 HandlerMethod가 아닌 경우 통과
        if (!(handler instanceof HandlerMethod handlerMethod)) {
            return true;
        }

        // @NoAuth 어노테이션이 있으면 인증 없이 통과
        if (handlerMethod.hasMethodAnnotation(NoAuth.class) ||
            handlerMethod.getBeanType().isAnnotationPresent(NoAuth.class)) {
            return true;
        }

        // Authorization 헤더 추출
        String authHeader = request.getHeader(AUTHORIZATION_HEADER);
        if (authHeader == null || !authHeader.startsWith(BEARER_PREFIX)) {
            sendUnauthorized(response, "인증 토큰이 없습니다");
            return false;
        }

        String token = authHeader.substring(BEARER_PREFIX.length());

        // 토큰 검증
        if (!jwtTokenProvider.validateToken(token)) {
            sendUnauthorized(response, "유효하지 않은 토큰입니다");
            return false;
        }

        // 토큰에서 사용자 정보 추출 후 request에 저장
        Long userId = jwtTokenProvider.getUserId(token);
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new IllegalStateException("사용자를 찾을 수 없습니다"));

        request.setAttribute("currentUser", user);

        // 역할 기반 인가 확인
        RequireRole requireRole = handlerMethod.getMethodAnnotation(RequireRole.class);
        if (requireRole != null && !user.hasRole(requireRole.value())) {
            sendForbidden(response, "권한이 없습니다");
            return false;
        }

        log.debug("인증 성공 - userId: {}, URI: {}", userId, request.getRequestURI());
        return true;
    }

    private void sendUnauthorized(HttpServletResponse response, String message)
        throws IOException {
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        writeJsonError(response, 401, message);
    }

    private void sendForbidden(HttpServletResponse response, String message)
        throws IOException {
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        writeJsonError(response, 403, message);
    }

    private void writeJsonError(HttpServletResponse response, int code, String message)
        throws IOException {
        response.setContentType("application/json;charset=UTF-8");
        String json = String.format(
            "{\"code\":%d,\"message\":\"%s\",\"timestamp\":\"%s\"}",
            code, message, LocalDateTime.now()
        );
        response.getWriter().write(json);
    }
}

// 인증 불필요 표시
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NoAuth {}

// 역할 기반 인가
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequireRole {
    String value();
}

@RestController
@RequestMapping("/api")
public class UserController {

    @NoAuth
    @GetMapping("/public/health")
    public String health() { return "OK"; }

    @GetMapping("/users/me")  // 기본 인증 필요
    public UserDto getMe(@RequestAttribute("currentUser") User user) {
        return UserDto.from(user);
    }

    @RequireRole("ADMIN")
    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

@Slf4j
@Component
public class LoggingInterceptor implements HandlerInterceptor {

    private static final String START_TIME_ATTR = "LOG_START_TIME";
    private static final String REQUEST_ID_ATTR = "REQUEST_ID";

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) {
        String requestId = UUID.randomUUID().toString().substring(0, 8);
        long startTime = System.currentTimeMillis();

        request.setAttribute(START_TIME_ATTR, startTime);
        request.setAttribute(REQUEST_ID_ATTR, requestId);

        // MDC에 요청 ID 설정 (로그 추적용)
        MDC.put("requestId", requestId);

        if (handler instanceof HandlerMethod handlerMethod) {
            log.info("[{}] 요청 시작 - {} {} | Controller: {}.{}",
                requestId,
                request.getMethod(),
                request.getRequestURI(),
                handlerMethod.getBeanType().getSimpleName(),
                handlerMethod.getMethod().getName()
            );
        } else {
            log.info("[{}] 요청 시작 - {} {}",
                requestId,
                request.getMethod(),
                request.getRequestURI()
            );
        }

        // 쿼리 파라미터 로깅 (민감 정보 제외)
        if (log.isDebugEnabled()) {
            logRequestParams(request, requestId);
        }

        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler,
                                 Exception ex) {
        Long startTime = (Long) request.getAttribute(START_TIME_ATTR);
        String requestId = (String) request.getAttribute(REQUEST_ID_ATTR);

        if (startTime != null) {
            long elapsed = System.currentTimeMillis() - startTime;
            int status = response.getStatus();

            if (ex != null) {
                log.error("[{}] 요청 실패 - {} {} | status={} | elapsed={}ms | error={}",
                    requestId,
                    request.getMethod(),
                    request.getRequestURI(),
                    status,
                    elapsed,
                    ex.getMessage()
                );
            } else {
                log.info("[{}] 요청 완료 - {} {} | status={} | elapsed={}ms",
                    requestId,
                    request.getMethod(),
                    request.getRequestURI(),
                    status,
                    elapsed
                );
            }
        }

        // MDC 정리 (ThreadLocal 기반이므로 반드시 제거)
        MDC.clear();
    }

    private void logRequestParams(HttpServletRequest request, String requestId) {
        // 민감 파라미터 목록
        Set<String> sensitiveParams = Set.of("password", "token", "secret", "key");

        Map<String, String> params = new HashMap<>();
        request.getParameterMap().forEach((key, values) -> {
            if (sensitiveParams.contains(key.toLowerCase())) {
                params.put(key, "***MASKED***");
            } else {
                params.put(key, String.join(",", values));
            }
        });

        if (!params.isEmpty()) {
            log.debug("[{}] 요청 파라미터: {}", requestId, params);
        }
    }
}

@Slf4j
@Component
public class PerformanceInterceptor implements HandlerInterceptor {

    private static final String START_TIME_KEY = "PERF_START_TIME";

    // 경고 임계값 (밀리초)
    private static final long WARN_THRESHOLD_MS = 500L;
    // 에러 임계값 (밀리초)
    private static final long ERROR_THRESHOLD_MS = 2000L;

    // 메트릭 수집용 (Micrometer 활용)
    private final MeterRegistry meterRegistry;
    private final Timer.Builder timerBuilder;

    public PerformanceInterceptor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.timerBuilder = Timer.builder("http.server.requests.custom");
    }

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) {
        request.setAttribute(START_TIME_KEY, System.nanoTime());
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler,
                                 Exception ex) {
        Long startNano = (Long) request.getAttribute(START_TIME_KEY);
        if (startNano == null) return;

        long elapsedNano = System.nanoTime() - startNano;
        long elapsedMs = elapsedNano / 1_000_000;

        String uri = request.getRequestURI();
        String method = request.getMethod();
        String status = String.valueOf(response.getStatus());

        // Micrometer 메트릭 기록
        timerBuilder
            .tag("uri", normalizeUri(uri))
            .tag("method", method)
            .tag("status", status)
            .register(meterRegistry)
            .record(elapsedNano, TimeUnit.NANOSECONDS);

        // 임계값에 따른 로그 레벨 구분
        if (elapsedMs >= ERROR_THRESHOLD_MS) {
            log.error("SLOW REQUEST - {} {} | {}ms (임계값: {}ms)",
                method, uri, elapsedMs, ERROR_THRESHOLD_MS);
        } else if (elapsedMs >= WARN_THRESHOLD_MS) {
            log.warn("SLOW REQUEST - {} {} | {}ms (임계값: {}ms)",
                method, uri, elapsedMs, WARN_THRESHOLD_MS);
        } else {
            log.debug("성능 측정 - {} {} | {}ms", method, uri, elapsedMs);
        }
    }

    /**
     * /users/123, /users/456 → /users/{id} 로 정규화
     * (메트릭 카디널리티 폭발 방지)
     */
    private String normalizeUri(String uri) {
        return uri.replaceAll("/\\d+", "/{id}");
    }
}

@Slf4j
@Component
public class RateLimitInterceptor implements HandlerInterceptor {

    // IP 당 요청 카운터 (실제 운영에서는 Redis 사용 권장)
    private final Map<String, RateLimitBucket> buckets = new ConcurrentHashMap<>();

    // 기본 설정: 분당 100 요청
    private static final int MAX_REQUESTS_PER_MINUTE = 100;
    private static final long WINDOW_MS = 60_000L;

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) throws Exception {
        String clientIp = getClientIp(request);
        String key = clientIp + ":" + request.getRequestURI();

        RateLimitBucket bucket = buckets.computeIfAbsent(key,
            k -> new RateLimitBucket(MAX_REQUESTS_PER_MINUTE, WINDOW_MS));

        if (!bucket.tryConsume()) {
            log.warn("Rate limit 초과 - IP: {}, URI: {}", clientIp, request.getRequestURI());

            response.setStatus(429); // Too Many Requests
            response.setHeader("Retry-After", String.valueOf(bucket.getRetryAfterSeconds()));
            response.setHeader("X-RateLimit-Limit", String.valueOf(MAX_REQUESTS_PER_MINUTE));
            response.setHeader("X-RateLimit-Remaining", "0");
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write(
                "{\"error\":\"요청 한도를 초과했습니다. 잠시 후 다시 시도해주세요.\"}"
            );
            return false;
        }

        // 남은 요청 수 헤더에 추가
        response.setHeader("X-RateLimit-Limit", String.valueOf(MAX_REQUESTS_PER_MINUTE));
        response.setHeader("X-RateLimit-Remaining", String.valueOf(bucket.getRemainingRequests()));

        return true;
    }

    private String getClientIp(HttpServletRequest request) {
        // 프록시 환경에서의 실제 IP 추출
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isBlank()) {
            return xForwardedFor.split(",")[0].trim();
        }
        String xRealIp = request.getHeader("X-Real-IP");
        if (xRealIp != null && !xRealIp.isBlank()) {
            return xRealIp;
        }
        return request.getRemoteAddr();
    }

    // 슬라이딩 윈도우 버킷 구현
    @Getter
    private static class RateLimitBucket {
        private final int maxRequests;
        private final long windowMs;
        private final Deque<Long> requestTimestamps = new ArrayDeque<>();

        RateLimitBucket(int maxRequests, long windowMs) {
            this.maxRequests = maxRequests;
            this.windowMs = windowMs;
        }

        synchronized boolean tryConsume() {
            long now = System.currentTimeMillis();
            long windowStart = now - windowMs;

            // 윈도우 밖의 오래된 요청 제거
            while (!requestTimestamps.isEmpty() &&
                   requestTimestamps.peekFirst() < windowStart) {
                requestTimestamps.pollFirst();
            }

            if (requestTimestamps.size() < maxRequests) {
                requestTimestamps.addLast(now);
                return true;
            }
            return false;
        }

        synchronized long getRetryAfterSeconds() {
            if (requestTimestamps.isEmpty()) return 0;
            long oldestRequest = requestTimestamps.peekFirst();
            return Math.max(0, (oldestRequest + windowMs - System.currentTimeMillis()) / 1000);
        }

        synchronized int getRemainingRequests() {
            return Math.max(0, maxRequests - requestTimestamps.size());
        }
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    private final AuthInterceptor authInterceptor;
    private final LoggingInterceptor loggingInterceptor;
    private final PerformanceInterceptor performanceInterceptor;
    private final RateLimitInterceptor rateLimitInterceptor;

    public WebMvcConfig(AuthInterceptor authInterceptor,
                        LoggingInterceptor loggingInterceptor,
                        PerformanceInterceptor performanceInterceptor,
                        RateLimitInterceptor rateLimitInterceptor) {
        this.authInterceptor = authInterceptor;
        this.loggingInterceptor = loggingInterceptor;
        this.performanceInterceptor = performanceInterceptor;
        this.rateLimitInterceptor = rateLimitInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        // 1. 로깅 인터셉터 (모든 요청)
        registry.addInterceptor(loggingInterceptor)
                .addPathPatterns("/**")
                .order(1); // 가장 먼저 실행

        // 2. 성능 측정 인터셉터 (API 경로만)
        registry.addInterceptor(performanceInterceptor)
                .addPathPatterns("/api/**")
                .order(2);

        // 3. Rate Limiting 인터셉터 (API 경로만)
        registry.addInterceptor(rateLimitInterceptor)
                .addPathPatterns("/api/**")
                .order(3);

        // 4. 인증 인터셉터 (공개 경로 제외)
        registry.addInterceptor(authInterceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns(
                    "/api/auth/login",
                    "/api/auth/signup",
                    "/api/public/**",
                    "/api/health",
                    "/swagger-ui/**",
                    "/v3/api-docs/**"
                )
                .order(4);
    }
}

// 100 TPS 환경: 단순하고 읽기 쉬운 구현 우선
@Component
public class SimpleAuthInterceptor implements HandlerInterceptor {

    @Autowired
    private TokenService tokenService;

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) throws Exception {
        String token = request.getHeader("Authorization");
        if (token == null || !tokenService.validate(token)) {
            response.sendError(401);
            return false;
        }
        return true;
    }
}

// 위험: ThreadLocal을 afterCompletion에서 정리하지 않으면 메모리 누수 발생
@Component
public class DangerousInterceptor implements HandlerInterceptor {

    private static final ThreadLocal<RequestContext> CONTEXT = new ThreadLocal<>();

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) {
        CONTEXT.set(new RequestContext(request)); // 설정
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler, Exception ex) {
        CONTEXT.remove(); // 반드시 제거! 없으면 스레드 풀에서 재사용될 때 이전 값이 남음
    }
}

@Slf4j
@Component
public class OptimizedLoggingInterceptor implements HandlerInterceptor {

    // 비동기 로그 처리로 I/O 블로킹 최소화
    private final AsyncLogger asyncLogger;

    // 인스턴스 변수는 공유 상태가 되므로 절대 요청 정보 저장 금지!
    // private String currentUser; // 절대 금지! 스레드 안전하지 않음

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) {
        // request 객체에 상태를 저장 (요청 스코프, 안전)
        request.setAttribute("START_TIME", System.nanoTime());
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                 HttpServletResponse response,
                                 Object handler, Exception ex) {
        Long startNano = (Long) request.getAttribute("START_TIME");
        if (startNano != null) {
            long elapsed = (System.nanoTime() - startNano) / 1_000_000;
            // 비동기로 로그 기록 (I/O 블로킹 없음)
            asyncLogger.log(request.getMethod(), request.getRequestURI(),
                response.getStatus(), elapsed);
        }
    }
}

@Component
public class UltraOptimizedInterceptor implements HandlerInterceptor {

    // 핫 패스: 자주 통과하는 경로를 BloomFilter나 Set으로 빠르게 처리
    private static final Set<String> WHITE_LIST_PATHS = Set.of(
        "/api/health", "/api/metrics", "/api/public/status"
    );

    // 컴파일된 패턴 재사용 (매번 컴파일 금지)
    private static final Pattern UUID_PATTERN =
        Pattern.compile("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) {
        String uri = request.getRequestURI();

        // 화이트리스트 경로는 즉시 통과 (Set.contains는 O(1))
        if (WHITE_LIST_PATHS.contains(uri)) {
            return true;
        }

        // handler 타입 체크를 최우선으로 (가장 저렴한 연산)
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }

        // 이후 비용이 드는 처리...
        return doActualWork(request, response, (HandlerMethod) handler);
    }

    private boolean doActualWork(HttpServletRequest request,
                                  HttpServletResponse response,
                                  HandlerMethod handler) {
        // 실제 처리 로직
        return true;
    }
}

// JWT 검증 결과 캐싱 예시
@Component
public class CachedAuthInterceptor implements HandlerInterceptor {

    private final Cache<String, UserInfo> tokenCache = Caffeine.newBuilder()
        .maximumSize(50_000)    // 최대 5만 개 캐시
        .expireAfterWrite(30, TimeUnit.SECONDS)  // 30초 TTL
        .build();

    @Override
    public boolean preHandle(HttpServletRequest request,
                              HttpServletResponse response,
                              Object handler) throws Exception {
        String token = extractToken(request);
        if (token == null) {
            response.sendError(401);
            return false;
        }

        // 캐시에서 먼저 확인 (O(1), JWT 파싱/검증 생략)
        UserInfo userInfo = tokenCache.get(token, this::validateAndGetUserInfo);

        if (userInfo == null) {
            response.sendError(401);
            return false;
        }

        request.setAttribute("userInfo", userInfo);
        return true;
    }

    private UserInfo validateAndGetUserInfo(String token) {
        // 실제 JWT 검증 (캐시 미스 시에만 실행)
        try {
            return jwtProvider.parse(token);
        } catch (Exception e) {
            return null; // null은 캐시되지 않음 (Caffeine 기본 동작)
        }
    }
}

// 위험: 멀티스레드 환경에서 데이터 오염
@Component
public class BadInterceptor implements HandlerInterceptor {
    private long startTime; // 공유 상태! 스레드 A의 값이 스레드 B에 의해 덮어쓰여짐

    @Override
    public boolean preHandle(...) {
        startTime = System.currentTimeMillis(); // 위험!
        return true;
    }

    @Override
    public void afterCompletion(...) {
        long elapsed = System.currentTimeMillis() - startTime; // 다른 스레드 값일 수 있음
    }
}

// 올바른 방법: request 객체에 저장
@Component
public class GoodInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, ...) {
        request.setAttribute("START_TIME", System.currentTimeMillis()); // 요청 스코프
        return true;
    }
}

// 함정: Controller에서 예외 발생 시 postHandle은 호출되지 않는다
@Override
public void postHandle(...) {
    // Controller가 예외를 던지면 이 코드는 실행되지 않는다
    log.info("처리 완료"); // 신뢰할 수 없는 로그
}

// 올바른 방법: 리소스 해제나 반드시 실행되어야 하는 코드는 afterCompletion에
@Override
public void afterCompletion(...) {
    // 예외 여부와 관계없이 항상 실행
    log.info("처리 완료 (예외 여부: {})", ex != null);
    cleanupResources(); // 여기에 넣어야 함
}

// 위험: false만 반환하고 응답을 작성하지 않으면 클라이언트는 빈 응답을 받는다
@Override
public boolean preHandle(...) {
    if (!isAuthenticated) {
        return false; // 응답 없음! 클라이언트 hang 또는 빈 응답
    }
    return true;
}

// 올바른 방법: false 반환 전 반드시 응답 작성
@Override
public boolean preHandle(HttpServletRequest request,
                          HttpServletResponse response, ...) throws Exception {
    if (!isAuthenticated) {
        response.setStatus(401);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write("{\"error\":\"인증이 필요합니다\"}");
        return false;
    }
    return true;
}

// 위험: 이 방법은 Spring Boot 자동 설정을 우회하여 예기치 않은 동작 발생 가능
@Configuration
public class BadConfig {
    @Bean
    public MappedInterceptor myInterceptor() {
        return new MappedInterceptor(new String[]{"/**"}, new AuthInterceptor()); // 비권장
    }
}

// 올바른 방법: WebMvcConfigurer.addInterceptors() 사용
@Configuration
public class GoodConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor())
                .addPathPatterns("/api/**");
    }
}

// 함정: 경로 끝에 슬래시가 있거나 없을 때 매칭이 다를 수 있다
registry.addInterceptor(authInterceptor)
        .addPathPatterns("/api/**")
        .excludePathPatterns("/api/public"); // /api/public/ 은 제외 안 됨!

// 안전한 방법: 슬래시 유무 모두 명시하거나 와일드카드 사용
registry.addInterceptor(authInterceptor)
        .addPathPatterns("/api/**")
        .excludePathPatterns(
            "/api/public",
            "/api/public/",
            "/api/public/**"  // 하위 경로까지 모두 제외
        );

// 올바른 방법
@Configuration
@RequiredArgsConstructor
public class WebMvcConfig implements WebMvcConfigurer {
    private final AuthInterceptor authInterceptor; // Spring Bean 주입

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor); // 주입받은 Bean 사용
    }
}