Feat/#143 응답 통일 - GlobalExceptionHandler 구체화

src/main/java/com/whereyouad/WhereYouAd/global/exception/AppException.java

@@ -2,13 +2,23 @@
 
 import lombok.Getter;
 
+import java.util.Map;
+
 @Getter
 public class AppException extends RuntimeException {
 
     private final BaseErrorCode errorCode;
+    private final Map<String, String> bind;
 
     public AppException(BaseErrorCode errorCode) {
         super(errorCode.getMessage());
         this.errorCode = errorCode;
+        this.bind = null;
+    }
+
+    public AppException(BaseErrorCode errorCode, Map<String, String> bind) {
+        super(errorCode.getMessage());
+        this.errorCode = errorCode;
+        this.bind = bind;
     }
 }

src/main/java/com/whereyouad/WhereYouAd/global/exception/ErrorCode.java

@@ -10,13 +10,25 @@
 @AllArgsConstructor
 public enum ErrorCode implements BaseErrorCode{
 
-    //400
-    BAD_REQUEST(HttpStatus.BAD_REQUEST, "잘못된 요청입니다.", "COMMON-001"),
-    INVALID_PARAMETER(HttpStatus.BAD_REQUEST, "요청 파라미터가 잘못되었습니다.", "COMMON-002"),
-    NOT_FOUND(HttpStatus.NOT_FOUND, "찾을 수 없습니다.", "COMMON-003"),
+    // 400
+    BAD_REQUEST(HttpStatus.BAD_REQUEST, "잘못된 요청입니다.", "COMMON_400_1"),
+    INVALID_PARAMETER(HttpStatus.BAD_REQUEST, "요청 파라미터가 잘못되었습니다.", "COMMON_400_2"),
+    JSON_PARSE_FAIL(HttpStatus.BAD_REQUEST, "JSON 파싱에 실패했습니다. Request body를 확인해주세요", "COMMON_400_3"),
+    PARAMETER_MISMATCH(HttpStatus.BAD_REQUEST, "쿼리 파라미터 타입이 맞지 않습니다.", "COMMON_400_4"),
+    NOT_FOUND_REQUEST_BODY(HttpStatus.BAD_REQUEST, "Request body가 없습니다.", "COMMON_400_5"),
 
-    //500
-    INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "서버 내부에서 에러가 발생하였습니다.", "COMMON-004"),
+    // 404
+    NOT_FOUND(HttpStatus.NOT_FOUND, "찾을 수 없습니다.", "COMMON_404_1"),
+    NOT_FOUND_URI(HttpStatus.NOT_FOUND, "존재하지 않는 URI입니다.", "COMMON_404_2"),
+
+    // 405
+    NOT_SUPPORT_HTTP_METHOD(HttpStatus.METHOD_NOT_ALLOWED, "잘못된 HTTP 메서드 입니다.", "COMMON_405_1"),
+
+    // 415
+    NOT_SUPPORT_CONTENT_TYPE(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "지원하지 않는 Content-Type 입니다.", "COMMON_415_1"),
+
+    // 500
+    INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "서버 내부에서 에러가 발생하였습니다.", "COMMON_500_1"),
     ;
 
     private final HttpStatus httpStatus;

src/main/java/com/whereyouad/WhereYouAd/global/exception/GlobalExceptionHandler.java

@@ -16,16 +16,38 @@
 
 
 import jakarta.servlet.http.HttpServletRequest;
+import jakarta.validation.ConstraintViolationException;
 import lombok.extern.slf4j.Slf4j;
+import com.fasterxml.jackson.databind.exc.InvalidFormatException;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.HttpMediaTypeNotSupportedException;
+import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.method.annotation.HandlerMethodValidationException;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+import org.springframework.web.servlet.resource.NoResourceFoundException;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 
 @Slf4j
 @RestControllerAdvice
 public class GlobalExceptionHandler {
 
+    // NPE — 주로 DTO 검증 누락이나 비즈니스 로직에서 발생
+    @ExceptionHandler(NullPointerException.class)
+    public ResponseEntity<ErrorResponse> handleNullPointerException(NullPointerException e, HttpServletRequest request) {
+        log.error("NullPointerException 발생 — 파일: {}, 라인: {}",
+                e.getStackTrace()[0].getFileName(), e.getStackTrace()[0].getLineNumber());
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        return ResponseEntity
+                .status(ErrorCode.INTERNAL_SERVER_ERROR.getHttpStatus())
+                .body(ErrorResponse.of(ErrorCode.INTERNAL_SERVER_ERROR, request));
+    }
+
     // 처리되지 않은 모든 예외를 잡는 핸들러
     @ExceptionHandler(Exception.class)
     public ResponseEntity<ErrorResponse> handleAllException(Exception e, HttpServletRequest request) {
@@ -44,7 +66,7 @@ public ResponseEntity<ErrorResponse> handleAllException(Exception e, HttpServlet
     public ResponseEntity<ErrorResponse> handleAppCustomException(AppException e, HttpServletRequest request) {
         log.error("AppException 발생: {}", e.getErrorCode().getMessage());
         log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
-        ErrorResponse errorResponse = ErrorResponse.of(e.getErrorCode(), request);
+        ErrorResponse errorResponse = ErrorResponse.of(e.getErrorCode(), request, e.getBind());
         return ResponseEntity
                 .status(e.getErrorCode().getHttpStatus())
                 .body(errorResponse);
@@ -53,17 +75,20 @@ public ResponseEntity<ErrorResponse> handleAppCustomException(AppException e, Ht
     //@Valid 검사 실패(필수 파라미터가 null 또는 공백) 인 경우 예외를 잡는 핸들러
     @ExceptionHandler(MethodArgumentNotValidException.class)
     public ResponseEntity<ErrorResponse> handleNotValidException(MethodArgumentNotValidException e, HttpServletRequest request) {
-        // 예시 결과: "email: 이메일 형식이 아닙니다, password: 비밀번호는 필수입니다"
-        String errorMessage = e.getBindingResult().getFieldErrors().stream()
-                .map(fieldError -> fieldError.getField() + ": " + fieldError.getDefaultMessage())
-                .collect(Collectors.joining(", "));
+        Map<String, String> errors = e.getBindingResult().getFieldErrors().stream()
+                .collect(Collectors.toMap(
+                        fieldError -> fieldError.getField(),
+                        fieldError -> fieldError.getDefaultMessage(),
+                        (existing, duplicate) -> existing
+                ));
 
-        log.error("MethodArgumentNotValidException 발생: {}", errorMessage);
+        log.error("MethodArgumentNotValidException 발생: {}", errors);
         log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
 
         ErrorResponse errorResponse = ErrorResponse.of(
                 ErrorCode.INVALID_PARAMETER,
-                request
+                request,
+                errors
         );
 
         return ResponseEntity
@@ -161,13 +186,181 @@ public ResponseEntity<Object> handleMethodArgumentTypeMismatch(MethodArgumentTyp
         }
 
         // Enum 변환 실패가 아닌 일반적인 타입 매스매치(예: Long 타입에 문자열 입력)인 경우
+        Map<String, String> errors = new HashMap<>();
+        errors.put(e.getName(), e.getValue() != null ? e.getValue().toString() : "null");
+
+        ErrorResponse errorResponse = ErrorResponse.of(
+                ErrorCode.PARAMETER_MISMATCH,
+                request,
+                errors
+        );
+
+        return ResponseEntity
+                .status(ErrorCode.PARAMETER_MISMATCH.getHttpStatus())
+                .body(errorResponse);
+    }
+
+    // @Valid 쿼리 파라미터 유효성 검사 실패
+    @ExceptionHandler(HandlerMethodValidationException.class)
+    public ResponseEntity<ErrorResponse> handleHandlerMethodValidationException(
+            HandlerMethodValidationException e,
+            HttpServletRequest request
+    ) {
+
+        Map<String, String> errors = new HashMap<>();
+        e.getParameterValidationResults().forEach(result ->
+                errors.put(
+                        result.getMethodParameter().getParameterName(),
+                        result.getResolvableErrors().get(0).getDefaultMessage()
+                )
+        );
+
+        log.error("HandlerMethodValidationException 발생: {}", errors);
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
         ErrorResponse errorResponse = ErrorResponse.of(
                 ErrorCode.INVALID_PARAMETER,
-                request
+                request,
+                errors
         );
 
         return ResponseEntity
-                .status(ErrorCode.INVALID_PARAMETER.getHttpStatus())
+                .status(HttpStatus.BAD_REQUEST)
+                .body(errorResponse);
+    }
+
+    // 필수 @RequestParam 누락
+    @ExceptionHandler(MissingServletRequestParameterException.class)
+    public ResponseEntity<ErrorResponse> handleMissingServletRequestParameterException(
+            MissingServletRequestParameterException e,
+            HttpServletRequest request
+    ) {
+
+        Map<String, String> errors = new HashMap<>();
+        errors.put(e.getParameterName(), "필수 파라미터입니다.");
+
+        log.error("MissingServletRequestParameterException 발생: 누락된 파라미터 '{}'", e.getParameterName());
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        ErrorResponse errorResponse = ErrorResponse.of(
+                ErrorCode.INVALID_PARAMETER,
+                request,
+                errors
+        );
+
+        return ResponseEntity
+                .status(HttpStatus.BAD_REQUEST)
                 .body(errorResponse);
     }
+
+    // @Validated 제약 조건 위반
+    @ExceptionHandler(ConstraintViolationException.class)
+    public ResponseEntity<ErrorResponse> handleConstraintViolationException(
+            ConstraintViolationException e,
+            HttpServletRequest request
+    ) {
+        Map<String, String> errors = new HashMap<>();
+        e.getConstraintViolations().forEach(violation -> {
+            String propertyPath = violation.getPropertyPath().toString();
+            String fieldName = propertyPath.contains(".")
+                    ? propertyPath.substring(propertyPath.lastIndexOf(".") + 1)
+                    : propertyPath;
+            errors.put(fieldName, violation.getMessage());
+        });
+
+        log.error("ConstraintViolationException 발생: {}", errors);
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        ErrorResponse errorResponse = ErrorResponse.of(
+                ErrorCode.INVALID_PARAMETER,
+                request,
+                errors
+        );
+
+        return ResponseEntity
+                .status(HttpStatus.BAD_REQUEST)
+                .body(errorResponse);
+    }
+
+    // Request Body JSON 파싱 실패 또는 Body 누락
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResponseEntity<ErrorResponse> handleHttpMessageNotReadableException(HttpMessageNotReadableException e, HttpServletRequest request) {
+
+        // 특정 필드의 타입 변환 실패 (예: String 필드에 숫자 타입 등)
+        if (e.getCause() instanceof InvalidFormatException cause) {
+            Map<String, String> errors = new HashMap<>();
+            String fieldName = cause.getPath().get(0).getFieldName();
+
+            if (cause.getValue().toString().isEmpty()) {
+                errors.put(fieldName, "빈칸을 변환할 수 없습니다.");
+            } else {
+                errors.put(fieldName, "'" + cause.getValue() + "'을(를) 변환할 수 없습니다.");
+            }
+
+            log.error("InvalidFormatException 발생: {}", errors);
+            log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+            return ResponseEntity
+                    .status(ErrorCode.JSON_PARSE_FAIL.getHttpStatus())
+                    .body(ErrorResponse.of(ErrorCode.JSON_PARSE_FAIL, request, errors));
+        }
+
+        // JSON 문법 자체가 잘못된 경우 (중괄호 누락, 따옴표 오류 등)
+        if (e.getMessage() != null && e.getMessage().contains("JSON parse error")) {
+            log.error("HttpMessageNotReadableException 발생: JSON 파싱 실패 - {}", e.getMessage());
+            log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+            return ResponseEntity
+                    .status(ErrorCode.JSON_PARSE_FAIL.getHttpStatus())
+                    .body(ErrorResponse.of(ErrorCode.JSON_PARSE_FAIL, request));
+        }
+
+        // Request Body 자체가 없는 경우
+        log.error("HttpMessageNotReadableException 발생: Request Body 없음");
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        return ResponseEntity
+                .status(ErrorCode.NOT_FOUND_REQUEST_BODY.getHttpStatus())
+                .body(ErrorResponse.of(ErrorCode.NOT_FOUND_REQUEST_BODY, request));
+    }
+
+    // 지원하지 않는 HTTP 메서드
+    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
+    public ResponseEntity<ErrorResponse> handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e, HttpServletRequest request) {
+        log.error("HttpRequestMethodNotSupportedException 발생: 지원하지 않는 메서드 '{}'", e.getMethod());
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        Map<String, String[]> errors = new HashMap<>();
+        errors.put("지원하는 메서드", e.getSupportedMethods());
+
+        return ResponseEntity
+                .status(ErrorCode.NOT_SUPPORT_HTTP_METHOD.getHttpStatus())
+                .body(ErrorResponse.of(ErrorCode.NOT_SUPPORT_HTTP_METHOD, request, errors));
+    }
+
+    // 존재하지 않는 URI
+    @ExceptionHandler(NoResourceFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNoResourceFoundException(NoResourceFoundException e, HttpServletRequest request) {
+        log.error("NoResourceFoundException 발생: 존재하지 않는 URI '{}'", request.getRequestURI());
+
+        return ResponseEntity
+                .status(ErrorCode.NOT_FOUND_URI.getHttpStatus())
+                .body(ErrorResponse.of(ErrorCode.NOT_FOUND_URI, request));
+    }
+
+    // 지원하지 않는 Content-Type
+    @ExceptionHandler(HttpMediaTypeNotSupportedException.class)
+    public ResponseEntity<ErrorResponse> handleHttpMediaTypeNotSupportedException(HttpMediaTypeNotSupportedException e, HttpServletRequest request) {
+        log.error("HttpMediaTypeNotSupportedException 발생: 지원하지 않는 Content-Type '{}'", e.getContentType());
+        log.error("에러가 발생한 지점 {}, {}", request.getMethod(), request.getRequestURI());
+
+        Map<String, String> errors = new HashMap<>();
+        if (e.getContentType() != null) {
+            errors.put("요청한 Content-Type", e.getContentType().toString());
+        }
+
+        return ResponseEntity
+                .status(ErrorCode.NOT_SUPPORT_CONTENT_TYPE.getHttpStatus())
+                .body(ErrorResponse.of(ErrorCode.NOT_SUPPORT_CONTENT_TYPE, request, errors));
+    }
 }

src/main/java/com/whereyouad/WhereYouAd/global/response/ErrorResponse.java

@@ -13,13 +13,15 @@ public class ErrorResponse extends BaseResponse {
     private final String message;
     private final String method;
     private final String requestURI;
+    private final Object errors;
 
-    private ErrorResponse(String code, String message, String method, String requestURI, HttpStatus httpStatus) {
+    private ErrorResponse(String code, String message, String method, String requestURI, HttpStatus httpStatus, Object errors) {
         super(httpStatus);
         this.code = code;
         this.message = message;
         this.method = method;
         this.requestURI = requestURI;
+        this.errors = errors;
     }
 
     public static ErrorResponse of(BaseErrorCode errorCode, HttpServletRequest request) {
@@ -28,7 +30,19 @@ public static ErrorResponse of(BaseErrorCode errorCode, HttpServletRequest reque
                 errorCode.getMessage(),
                 request.getMethod(),
                 request.getRequestURI(),
-                errorCode.getHttpStatus()
+                errorCode.getHttpStatus(),
+                null
+        );
+    }
+
+    public static ErrorResponse of(BaseErrorCode errorCode, HttpServletRequest request, Object errors) {
+        return new ErrorResponse(
+                errorCode.getCode(),
+                errorCode.getMessage(),
+                request.getMethod(),
+                request.getRequestURI(),
+                errorCode.getHttpStatus(),
+                errors
         );
     }
 }