import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import org.owasp.html.HtmlPolicyBuilder;
import org.owasp.html.PolicyFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class OwaspXssFilter implements Filter {

    private final PolicyFactory policy;

    public OwaspXssFilter() {
        this.policy = new HtmlPolicyBuilder()
            // 블록 요소
            .allowElements(
                "p", "div", "br",
                "h1", "h2", "h3", "h4", "h5", "h6",
                "blockquote", "pre"
            )
            // 인라인 요소
            .allowElements(
                "span", "strong", "em", "u", "s", "code"
            )
            // 리스트
            .allowElements("ul", "ol", "li")
            // 링크
            .allowElements("a")
            .allowUrlProtocols("https", "http")
            .allowAttributes("href").onElements("a")
            .requireRelNofollowOnLinks()
            // 이미지
            .allowElements("img")
            .allowAttributes("src", "alt", "title").onElements("img")
            // 테이블
            .allowElements(
                "table", "thead", "tbody", "tfoot",
                "tr", "th", "td", "caption"
            )
            // 글로벌 속성
            .allowAttributes("class").globally()
            .allowAttributes("id").globally()
            .toFactory();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        OwaspXssRequestWrapper wrappedRequest =
            new OwaspXssRequestWrapper(httpRequest, policy);
        chain.doFilter(wrappedRequest, response);
    }
}

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.owasp.html.PolicyFactory;

import java.util.*;

public class OwaspXssRequestWrapper extends HttpServletRequestWrapper {

    private final PolicyFactory policy;

    public OwaspXssRequestWrapper(HttpServletRequest request,
                                  PolicyFactory policy) {
        super(request);
        this.policy = policy;
    }

    @Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        return sanitize(value);
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] values = super.getParameterValues(name);
        if (values == null) {
            return null;
        }

        String[] sanitizedValues = new String[values.length];
        for (int i = 0; i < values.length; i++) {
            sanitizedValues[i] = sanitize(values[i]);
        }
        return sanitizedValues;
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        Map<String, String[]> originalMap = super.getParameterMap();
        Map<String, String[]> sanitizedMap = new HashMap<>();

        for (Map.Entry<String, String[]> entry : originalMap.entrySet()) {
            String[] values = entry.getValue();
            String[] sanitizedValues = new String[values.length];
            for (int i = 0; i < values.length; i++) {
                sanitizedValues[i] = sanitize(values[i]);
            }
            sanitizedMap.put(entry.getKey(), sanitizedValues);
        }

        return Collections.unmodifiableMap(sanitizedMap);
    }

    private String sanitize(String value) {
        if (value == null) {
            return null;
        }

        // 1단계: OWASP로 XSS 방어
        String sanitized = policy.sanitize(value);

        // 2단계: 안전한 문자만 선택적 복원
        sanitized = sanitized.replace("&#34;", "\"");
        sanitized = sanitized.replace("&quot;", "\"");
        sanitized = sanitized.replace("&#39;", "'");
        sanitized = sanitized.replace("&apos;", "'");
        sanitized = sanitized.replace("&#x27;", "'");
        sanitized = sanitized.replace("&#92;", "\\");
        sanitized = sanitized.replace("&#x5c;", "\\");
        sanitized = sanitized.replace("&#x5C;", "\\");
        sanitized = sanitized.replace("&#64;", "@");
        sanitized = sanitized.replace("&#x40;", "@");
        sanitized = sanitized.replace("&#43;", "+");
        sanitized = sanitized.replace("&#x2b;", "+");
        sanitized = sanitized.replace("&#x2B;", "+");
        sanitized = sanitized.replace("&#61;", "=");
        sanitized = sanitized.replace("&#x3d;", "=");
        sanitized = sanitized.replace("&#x3D;", "=");

        // &amp; 복원은 반드시 마지막에 수행
        sanitized = sanitized.replace("&amp;", "&");

        return sanitized;
    }
}

import org.junit.jupiter.api.*;
import org.owasp.html.HtmlPolicyBuilder;
import org.owasp.html.PolicyFactory;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class OwaspPolicyTest {

    private PolicyFactory policy;

    @BeforeEach
    public void setUp() {
        this.policy = new HtmlPolicyBuilder()
            .allowElements("p", "div", "br", "h1", "h2", "h3", "h4", "h5", "h6",
                           "blockquote", "pre", "span", "strong", "em", "u", "s",
                           "code", "ul", "ol", "li", "a", "img",
                           "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption")
            .allowUrlProtocols("https", "http")
            .allowAttributes("href").onElements("a")
            .requireRelNofollowOnLinks()
            .allowAttributes("src", "alt", "title").onElements("img")
            .allowAttributes("class").globally()
            .allowAttributes("id").globally()
            .toFactory();
    }

    @Test
    @Order(1)
    @DisplayName("JSON 문자열: sanitize 후 선택적 복원으로 원본 보존")
    public void testJsonString() {
        String input = "[\"1\",\"2\",\"3\"]";
        String sanitized = policy.sanitize(input);
        String restored = sanitized.replace(""", "\"")
                                   .replace(""", "\"");

        Assertions.assertEquals(input, restored);
    }

    @Test
    @Order(2)
    @DisplayName("XSS script 태그: 완전 제거")
    public void testXssScriptTag() {
        String input = "<script>alert('XSS')</script>";
        String sanitized = policy.sanitize(input);

        Assertions.assertTrue(sanitized.isEmpty());
    }

    @Test
    @Order(3)
    @DisplayName("안전한 HTML 태그: 보존")
    public void testSafeHtmlPreserved() {
        String input = "<h2>제목</h2><p><strong>중요</strong> 내용입니다</p>";
        String sanitized = policy.sanitize(input);

        Assertions.assertTrue(sanitized.contains("<h2>"));
        Assertions.assertTrue(sanitized.contains("<strong>"));
        Assertions.assertTrue(sanitized.contains("<p>"));
    }

    @Test
    @Order(4)
    @DisplayName("iframe XSS 공격: 위험 태그만 제거, 텍스트 보존")
    public void testIframeXssRemoved() {
        String input = "안녕하세요.<iframe srcdoc=\"<svg/onload=alert(4)>\"></iframe>감사합니다.";
        String sanitized = policy.sanitize(input);

        Assertions.assertFalse(sanitized.contains("iframe"));
        Assertions.assertFalse(sanitized.contains("onload"));
        Assertions.assertTrue(sanitized.contains("안녕하세요."));
        Assertions.assertTrue(sanitized.contains("감사합니다."));
    }

    @Test
    @Order(5)
    @DisplayName("이벤트 핸들러 공격: onclick 제거")
    public void testEventHandlerRemoved() {
        String input = "<div onclick=\"alert('xss')\">클릭</div>";
        String sanitized = policy.sanitize(input);

        Assertions.assertFalse(sanitized.contains("onclick"));
        Assertions.assertTrue(sanitized.contains("클릭"));
    }

    @Test
    @Order(6)
    @DisplayName("javascript: 프로토콜 공격: 링크 제거")
    public void testJavascriptProtocolRemoved() {
        String input = "<a href=\"javascript:alert('xss')\">링크</a>";
        String sanitized = policy.sanitize(input);

        Assertions.assertFalse(sanitized.contains("javascript"));
    }
}

@RestControllerAdvice
public class XssRequestBodyAdvice implements RequestBodyAdvice {

    private final PolicyFactory policy;

    public XssRequestBodyAdvice(OwaspXssFilter xssFilter) {
        this.policy = xssFilter.getPolicy();
    }

    @Override
    public boolean supports(MethodParameter parameter, Type targetType,
                            Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage,
            MethodParameter parameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        return inputMessage;
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage,
            MethodParameter parameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        sanitizeStringFields(body);
        return body;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage,
            MethodParameter parameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    private void sanitizeStringFields(Object obj) {
        if (obj == null) return;
        for (Field field : obj.getClass().getDeclaredFields()) {
            if (field.getType() == String.class) {
                field.setAccessible(true);
                try {
                    String value = (String) field.get(obj);
                    if (value != null) {
                        field.set(obj, policy.sanitize(value));
                    }
                } catch (IllegalAccessException e) {
                    // skip
                }
            }
        }
    }
}

@Getter
@RequiredArgsConstructor
public enum ApiErrorCode {

    // 400 Bad Request
    BAD_REQUEST("E400", HttpStatus.BAD_REQUEST),
    INVALID_PARAMETER("E400.01", HttpStatus.BAD_REQUEST),

    // 401 Unauthorized
    UNAUTHORIZED("E401", HttpStatus.UNAUTHORIZED),

    // 404 Not Found
    NOT_FOUND("E404", HttpStatus.NOT_FOUND),

    // 409 Conflict
    CONFLICT("E409", HttpStatus.CONFLICT),
    ALREADY_EXISTS("E409.01", HttpStatus.CONFLICT),

    // 500 Internal Server Error
    INTERNAL_SERVER_ERROR("E500", HttpStatus.INTERNAL_SERVER_ERROR),
    EXTERNAL_API_ERROR("E500.01", HttpStatus.INTERNAL_SERVER_ERROR);

    private final String code;
    private final HttpStatus status;
}

@Getter
public class ApiException extends RuntimeException {
    private final ApiErrorCode errorCode;

    public ApiException(ApiErrorCode errorCode) {
        super(errorCode.getCode());
        this.errorCode = errorCode;
    }

    public ApiException(ApiErrorCode errorCode, Throwable cause) {
        super(errorCode.getCode(), cause);
        this.errorCode = errorCode;
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiErrorCodeExamples {
    ApiErrorCode[] value();
}

@Getter
@AllArgsConstructor
public class ErrorResponse {
    private final String code;
    private final String message;
}

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.support.MessageSourceAccessor;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
@Order(Ordered.HIGHEST_PRECEDENCE)
@RequiredArgsConstructor
public class GlobalExceptionHandler {

    private final MessageSourceAccessor messageSourceAccessor;

    @ExceptionHandler(ApiException.class)
    public ResponseEntity<ErrorResponse> handleApiException(ApiException ex) {
        ApiErrorCode errorCode = ex.getErrorCode();
        String message = messageSourceAccessor.getMessage(
            errorCode.getCode(), "에러가 발생했습니다");

        log.error("ApiException: code={}, status={}, message={}",
                errorCode.getCode(), errorCode.getStatus(), message, ex);

        ErrorResponse response = new ErrorResponse(errorCode.getCode(), message);
        return ResponseEntity.status(errorCode.getStatus()).body(response);
    }
}

@Configuration
@RequiredArgsConstructor
public class SwaggerConfig {

    private final MessageSourceAccessor messageSourceAccessor;

    @Bean
    public OperationCustomizer operationCustomizer() {
        return (Operation operation, HandlerMethod handlerMethod) -> {
            ApiErrorCodeExamples annotation =
                handlerMethod.getMethodAnnotation(ApiErrorCodeExamples.class);
            if (annotation != null) {
                generateErrorExamples(operation, annotation.value());
            }
            return operation;
        };
    }

    private void generateErrorExamples(Operation operation, ApiErrorCode[] errorCodes) {
        Map<Integer, List<ApiErrorCode>> groupedByStatus = Arrays.stream(errorCodes)
                .collect(Collectors.groupingBy(code -> code.getStatus().value()));

        groupedByStatus.forEach((status, codes) -> {
            MediaType mediaType = new MediaType();
            codes.forEach(code -> mediaType.addExamples(
                code.getCode(), createExample(code)));

            operation.getResponses().addApiResponse(
                String.valueOf(status),
                new ApiResponse()
                    .description("에러 응답")
                    .content(new Content()
                        .addMediaType("application/json", mediaType))
            );
        });
    }

    private Example createExample(ApiErrorCode errorCode) {
        String message = messageSourceAccessor.getMessage(
            errorCode.getCode(), "에러가 발생했습니다");
        Example example = new Example();
        example.setValue(Map.of(
            "code", errorCode.getCode(),
            "message", message
        ));
        example.setDescription(message);
        return example;
    }
}

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

    private final UserService userService;

    @ApiResponses({
        @ApiResponse(responseCode = "400", description = "잘못된 요청입니다.",
            content = @Content(schema = @Schema(implementation = ErrorResponse.class))),
        @ApiResponse(responseCode = "401", description = "인증이 필요합니다.",
            content = @Content(schema = @Schema(implementation = ErrorResponse.class))),
        @ApiResponse(responseCode = "404", description = "요청한 리소스를 찾을 수 없습니다.",
            content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
    })
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUser(id));
    }
}

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

    private final UserService userService;

    @ApiErrorCodeExamples({
        ApiErrorCode.BAD_REQUEST, ApiErrorCode.NOT_FOUND, ApiErrorCode.UNAUTHORIZED
    })
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUser(id));
    }
}

@Service
public class UserService {

    public UserDto getUser(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new ApiException(ApiErrorCode.NOT_FOUND));
    }
}

try {
    externalApiCall();
} catch (Exception e) {
    throw new ApiException(ApiErrorCode.EXTERNAL_API_ERROR, e);
}

@Configuration
public class TimerConfig {

    @Bean
    public WebMvcTagsProvider webMvcTagsProvider() {
        return new DefaultWebMvcTagsProvider() {
            @Override
            public Iterable<Tag> getTags(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler, Throwable exception) {
                // URI Cardinality Explosion 방지를 위해 정규화된 URI 템플릿 사용
                String uriTemplate = (String) request.getAttribute(
                    HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
                if (uriTemplate == null) {
                    uriTemplate = request.getRequestURI(); // fallback
                }

                return List.of(
                    Tag.of("uri", uriTemplate),
                    Tag.of("method", request.getMethod()),
                    Tag.of("status", String.valueOf(response.getStatus())),
                    Tag.of("exception", exception == null
                        ? "None" : exception.getClass().getSimpleName()),
                    Tag.of("outcome", response.getStatus() >= 200
                        && response.getStatus() < 300 ? "SUCCESS" : "ERROR")
                );
            }
        };
    }

}

@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/actuator/**");
    }
}

import com.github.f4b6a3.uuid.UuidCreator;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.support.SpringBeanAutowiringSupport;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * logging 공통 filter - MDC를 이용해 프로세스 이력 추적
 */
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class LoggingSetupFilter implements Filter {

    public static final String KEY_TRACE_ID = "traceId";

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(
            this, filterConfig.getServletContext()
        );
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain filterChain) throws IOException, ServletException {
        try {
            if (request instanceof HttpServletRequest) {
                String traceId = UuidCreator.getTimeOrderedWithHash().toString();
                MDC.put(KEY_TRACE_ID, traceId);
                request.setAttribute(KEY_TRACE_ID, MDC.get(KEY_TRACE_ID));
            }

            filterChain.doFilter(request, response);
        } finally {
            MDC.remove(KEY_TRACE_ID);
            request.removeAttribute(KEY_TRACE_ID);
        }
    }

    @Override
    public void destroy() {}
}

import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;

import java.util.Map;

public class MdcTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 현재 스레드의 MDC 컨텍스트를 캡처
        Map<String, String> contextMap = MDC.getCopyOfContextMap();

        return () -> {
            // 비동기 스레드에 MDC 컨텍스트 설정
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                runnable.run();
            } finally {
                // 스레드 풀 반납 전 MDC 정리
                MDC.clear();
            }
        };
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean(name = "threadPoolTaskExecutor")
    public Executor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(3);
        taskExecutor.setMaxPoolSize(30);
        taskExecutor.setQueueCapacity(100);
        taskExecutor.setThreadNamePrefix("AsyncExecutor-");
        taskExecutor.setTaskDecorator(new MdcTaskDecorator());  // MDC 전파 핵심
        taskExecutor.initialize();
        return taskExecutor;
    }
}

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.IThrowableProxy;
import ch.qos.logback.classic.spi.StackTraceElementProxy;
import ch.qos.logback.core.LayoutBase;

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.HashSet;
import java.util.Set;

/**
 * Slack 로그 전송을 위한 커스텀 레이아웃
 * - 로그 레벨별 이모지
 * - traceId 포함
 * - ERROR 시 전체 스택 트레이스
 * - 비즈니스 예외 필터링
 */
public class SlackLogLayout extends LayoutBase<ILoggingEvent> {

    private static final DateTimeFormatter DATE_FORMATTER =
        DateTimeFormatter.ofPattern("yy-MM-dd HH:mm:ss")
            .withZone(ZoneId.systemDefault());

    private String logPrefix = "unknown";
    private Set<String> excludedExceptions = new HashSet<>();

    @Override
    public String doLayout(ILoggingEvent event) {
        // 제외 대상 예외는 빈 문자열 반환 (Slack 전송 안 함)
        if (isExcludedException(event)) {
            return "";
        }

        StringBuilder sb = new StringBuilder();

        // 1. 레벨별 이모지
        String emoji = getEmojiForLevel(event.getLevel());
        sb.append(emoji).append(" *[").append(event.getLevel()).append("]*\n");

        // 2. 기본 정보
        String moduleName = getLogPrefix(event);
        String timestamp = DATE_FORMATTER.format(
            Instant.ofEpochMilli(event.getTimeStamp())
        );
        String traceId = event.getMDCPropertyMap().getOrDefault("traceId", "N/A");
        String loggerName = getShortLoggerName(event.getLoggerName());

        sb.append("[").append(moduleName)
          .append(" ").append(timestamp)
          .append(" TRACE_ID=").append(traceId)
          .append("] ").append(loggerName).append("\n");

        // 3. ERROR + 예외 → 스택 트레이스 포함
        if (event.getLevel().isGreaterOrEqual(Level.ERROR)
            && event.getThrowableProxy() != null) {
            appendErrorDetails(sb, event);
        } else {
            sb.append("> ").append(event.getFormattedMessage()).append("\n");
        }

        return sb.toString();
    }

    private void appendErrorDetails(StringBuilder sb, ILoggingEvent event) {
        IThrowableProxy throwableProxy = event.getThrowableProxy();

        String formattedMessage = event.getFormattedMessage();
        if (formattedMessage != null && !formattedMessage.isEmpty()) {
            sb.append(formattedMessage).append("\n");
        }

        sb.append("```\n");

        // 예외 클래스명 + 메시지
        sb.append(throwableProxy.getClassName());
        String message = throwableProxy.getMessage();
        if (message != null && !message.isEmpty()) {
            sb.append(": ").append(message);
        }
        sb.append("\n");

        // 스택 트레이스 전체 출력
        StackTraceElementProxy[] stackTrace =
            throwableProxy.getStackTraceElementProxyArray();
        if (stackTrace != null && stackTrace.length > 0) {
            for (StackTraceElementProxy element : stackTrace) {
                sb.append("  at ").append(element.toString()).append("\n");
            }
        }

        // Caused by 체인 출력
        IThrowableProxy cause = throwableProxy.getCause();
        while (cause != null) {
            sb.append("Caused by: ").append(cause.getClassName());
            if (cause.getMessage() != null) {
                sb.append(": ").append(cause.getMessage());
            }
            sb.append("\n");

            StackTraceElementProxy[] causeStackTrace =
                cause.getStackTraceElementProxyArray();
            if (causeStackTrace != null) {
                for (StackTraceElementProxy element : causeStackTrace) {
                    sb.append("  at ").append(element.toString()).append("\n");
                }
            }
            cause = cause.getCause();
        }

        sb.append("```\n");
    }

    private String getEmojiForLevel(Level level) {
        if (level.isGreaterOrEqual(Level.ERROR)) return ":rotating_light:";
        if (level.isGreaterOrEqual(Level.WARN))  return ":warning:";
        if (level.isGreaterOrEqual(Level.INFO))  return ":information_source:";
        return ":bug:";
    }

    private String getLogPrefix(ILoggingEvent event) {
        if (logPrefix != null && !logPrefix.equals("unknown")) {
            return logPrefix;
        }
        try {
            String contextLogPrefix =
                event.getLoggerContextVO().getPropertyMap().get("LOG_PREFIX");
            if (contextLogPrefix != null && !contextLogPrefix.isEmpty()) {
                this.logPrefix = contextLogPrefix;
                return contextLogPrefix;
            }
            return "unknown";
        } catch (Exception e) {
            return "unknown";
        }
    }

    public void setLogPrefix(String logPrefix) {
        this.logPrefix = logPrefix;
    }

    public void setExcludedExceptions(String excludedExceptions) {
        if (excludedExceptions != null && !excludedExceptions.trim().isEmpty()) {
            String[] exceptions = excludedExceptions.split(",");
            this.excludedExceptions = new HashSet<>();
            for (String exception : exceptions) {
                String trimmed = exception.trim();
                if (!trimmed.isEmpty()) {
                    this.excludedExceptions.add(trimmed);
                }
            }
        }
    }

    private boolean isExcludedException(ILoggingEvent event) {
        if (excludedExceptions.isEmpty() || event.getThrowableProxy() == null) {
            return false;
        }

        String exceptionClassName = event.getThrowableProxy().getClassName();

        for (String excluded : excludedExceptions) {
            if (exceptionClassName.equals(excluded)) return true;
            if (exceptionClassName.endsWith("." + excluded)) return true;
        }

        return false;
    }

    private String getShortLoggerName(String fullLoggerName) {
        if (fullLoggerName == null || fullLoggerName.isEmpty()) {
            return "Unknown";
        }
        int lastDot = fullLoggerName.lastIndexOf(".");
        if (lastDot >= 0 && lastDot < fullLoggerName.length() - 1) {
            return fullLoggerName.substring(lastDot + 1);
        }
        return fullLoggerName;
    }
}

@Slf4j
@Service
public class OrderService {

    public void processOrder(Long orderId) {
        try {
            // 비즈니스 로직
        } catch (Exception e) {
            // 이 ERROR 로그가 자동으로 Slack에 전송됨
            log.error("주문 처리 실패. orderId={}", orderId, e);
            throw e;
        }
    }
}

@RestController
public class MonitorController {

    // slackLogger 이름의 로거 사용
    private static final Logger slackLog = LoggerFactory.getLogger("slackLogger");

    @PostMapping("/api/deploy/notify")
    public String notifyDeploy() {
        slackLog.info("v2.5.0 배포 완료 - 정상 구동 확인");
        return "OK";
    }
}

@Slf4j
@Service
public class NotificationService {

    @Async("threadPoolTaskExecutor")
    public void sendPushAsync(Long memberId, String message) {
        // traceId가 비동기 스레드에서도 유지됨
        log.info("푸시 전송 시작. memberId={}", memberId);

        try {
            // 푸시 전송 로직
        } catch (Exception e) {
            // ERROR → Slack 자동 전송 (traceId 포함)
            log.error("푸시 전송 실패. memberId={}", memberId, e);
        }
    }
}

public class DeliveryService { 
    public void delivery (String deliveryType) { 
        if ("WALK".equals(deliveryType)) { 
            // 도보
         } else if ("TRUCK".equals(deliveryType)) { 
            // 트럭
         } else if ("TRAIN".equals(deliveryType)) { 
            // 기차
         } 
    } 
}

public interface DeliveryStrategy {
    void deliver();
}

@Component("WALK")
public class WalkDeliveryStrategy implements DeliveryStrategy {
  @Override
  public void deliver() {
    System.out.println("도보로 배송합니다.");
  }
}

@Component("TRUCK")
public class TruckDeliveryStrategy implements DeliveryStrategy {
  @Override
  public void deliver() {
    System.out.println("트럭으로 배송합니다.");
  }
}

@Component("TRAIN")
public class TrainDeliveryStrategy implements DeliveryStrategy {
  @Override
  public void deliver() {
    System.out.println("기차로 배송합니다.");
  }
}

@Component("SHIP")
public class ShipDeliveryStrategy implements DeliveryStrategy {
    @Override
    public void deliver() {
        System.out.println("선박으로 배송합니다.");
    }
}

@Component("AIRPLANE")
public class AirplaneDeliveryStrategy implements DeliveryStrategy {
  @Override
  public void deliver() {
    System.out.println("항공으로 배송합니다.");
  }
}

@Service
public class DeliveryService {
    
    private final Map<String, DeliveryStrategy> strategyMap;

    public DeliveryService(Map<String, DeliveryStrategy> strategyMap) {
        this.strategyMap = strategyMap;
    }

    public void deliver(String deliveryType) {
        DeliveryStrategy strategy = strategyMap.get(deliveryType);
        if (strategy == null) {
            throw new IllegalArgumentException("지원하지 않는 배송 타입: " + deliveryType);
        }
        strategy.deliver();
    }
}

RestTemplate restTemplate = new RestTemplate();
Order order = restTemplate.getForObject("https://api.example.com/orders/{id}", Order.class, id);

WebClient client = WebClient.create("https://api.example.com");

Mono<Order> orderMono = client.get()
    .uri("/orders/{id}", id)
    .retrieve()
    .bodyToMono(Order.class);

RestClient restClient = RestClient.create("https://api.example.com");

Order order = restClient.get()
        .uri("/orders/{id}", id)
        .retrieve()
        .body(Order.class);

@RestClient
public interface OrderClient {
    @GetExchange("/orders/{id}")
    Order getOrder(@PathVariable("id") Long id);
}

// 사용 예시
Order order = orderClient.getOrder(123L);

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/orders/1"))
        .build();

HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

@FeignClient(name = "orderClient", url = "https://api.example.com")
public interface OrderClient {
    @GetMapping("/orders/{id}")
    Order getOrder(@PathVariable String id);
}

import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.*;

class PointServiceTest {

    private final PointService pointService = new PointService();

    @Test
    void 보유포인트보다_적은금액을_차감요청하면_정상적으로_차감된다() {
        // given
        int 보유포인트 = 1000;
        int 차감요청 = 300;

        // when
        int 결과 = pointService.deduct(보유포인트, 차감요청);

        // then
        assertThat(결과).isEqualTo(700);
    }

    @Test
    void 보유포인트보다_많은금액을_차감요청하면_예외가_발생한다() {
        // given
        int 보유포인트 = 500;
        int 차감요청 = 1000;

        // when & then
        assertThatThrownBy(() -> pointService.deduct(보유포인트, 차감요청))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("보유 포인트보다 많이 차감할 수 없습니다.");
    }
}

@SpringBootTest
@Testcontainers
class UserRepositoryIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgresDB = new PostgreSQLContainer<>("postgres:13")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");

    @Autowired
    private UserRepository userRepository;

    @DynamicPropertySource
    static void overrideProps(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgresDB::getJdbcUrl);
        registry.add("spring.datasource.username", postgresDB::getUsername);
        registry.add("spring.datasource.password", postgresDB::getPassword);
    }

    @Test
    void 유저_엔티티를_저장하면_아이디로_조회할_수_있다() {
        // given
        User user = new User();
        user.setEmail("test@example.com");

        // when
        userRepository.save(user);

        // then
        Optional<User> found = userRepository.findById(user.getId());
        assertThat(found).isPresent();
        assertThat(found.get().getEmail()).isEqualTo("test@example.com");
    }
}

@SpringBootTest
@AutoConfigureMockMvc
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class WeatherServiceIntegrationTest {

    private static final MockWebServer mockWebServer = new MockWebServer();

    @Autowired
    private WeatherService weatherService;

    @DynamicPropertySource
    static void overrideBaseUrl(DynamicPropertyRegistry registry) throws IOException {
        mockWebServer.start();
        registry.add("weather.api.base-url", () -> mockWebServer.url("/").toString());
    }

    @BeforeEach
    void setupMockResponse() {
        mockWebServer.enqueue(new MockResponse()
                .setBody("""
                    {
                        "city": "Seoul",
                        "temperature": 26
                    }
                """)
                .addHeader("Content-Type", "application/json"));
    }

    @Test
    void 도시명으로_날씨조회시_API호출후_온도반환() {
        int temp = weatherService.getWeather("Seoul");
        assertThat(temp).isEqualTo(26);
    }

    @AfterAll
    static void shutdown() throws IOException {
        mockWebServer.shutdown();
    }
}

@SpringBootTest
@AutoConfigureMockMvc
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class UserRegistrationE2ETest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void 회원가입_및_로그인_시나리오_테스트() throws Exception {
        // 1. 회원가입 요청
        mockMvc.perform(post("/api/users/register")
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                    {
                        "email": "test@example.com",
                        "password": "secure123!",
                        "nickname": "tester"
                    }
                """))
                .andExpect(status().isOk());

        // 2. 로그인 요청 → JWT 반환
        MvcResult result = mockMvc.perform(post("/api/users/login")
                .contentType(MediaType.APPLICATION_JSON)
                .content("""
                    {
                        "email": "test@example.com",
                        "password": "secure123!"
                    }
                """))
                .andExpect(status().isOk())
                .andReturn();

        String response = result.getResponse().getContentAsString();
        String token = JsonPath.read(response, "$.token");

        // 3. 로그인된 상태로 마이페이지 접근
        mockMvc.perform(get("/api/users/me")
                .header("Authorization", "Bearer " + token))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.email").value("test@example.com"));
    }
}