JECT-Study
diff --git a/‎.github/workflows/continuous-intergration.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/continuous-intergration.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎build.gradle‎
Lines changed: 10 additions & 5 deletions b/‎build.gradle‎
Lines changed: 10 additions & 5 deletions
diff --git a/‎scripts/start.sh‎
Lines changed: 1 addition & 1 deletion b/‎scripts/start.sh‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/main/java/org/ject/support/common/exception/ErrorCode.java‎
Lines changed: 6 additions & 0 deletions b/‎src/main/java/org/ject/support/common/exception/ErrorCode.java‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎src/main/java/org/ject/support/common/exception/GlobalErrorCode.java‎
Lines changed: 25 additions & 14 deletions b/‎src/main/java/org/ject/support/common/exception/GlobalErrorCode.java‎
Lines changed: 25 additions & 14 deletions
diff --git a/‎src/main/java/org/ject/support/common/exception/GlobalExceptionHandler.java‎
Lines changed: 72 additions & 20 deletions b/‎src/main/java/org/ject/support/common/exception/GlobalExceptionHandler.java‎
Lines changed: 72 additions & 20 deletions
diff --git a/‎src/main/java/org/ject/support/common/response/ErrorResponse.java‎
Lines changed: 34 additions & 0 deletions b/‎src/main/java/org/ject/support/common/response/ErrorResponse.java‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎src/main/java/org/ject/support/common/response/ResponseWrapper.java‎
Lines changed: 3 additions & 3 deletions b/‎src/main/java/org/ject/support/common/response/ResponseWrapper.java‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎src/main/java/org/ject/support/common/security/CustomSuccessHandler.java‎
Lines changed: 5 additions & 4 deletions b/‎src/main/java/org/ject/support/common/security/CustomSuccessHandler.java‎
Lines changed: 5 additions & 4 deletions
@@ -33,7 +33,7 @@ jobs:
         uses: gradle/gradle-build-action@v3
         with:
           arguments: build
-          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/develop' }}
+          cache-read-only: ${{ github.ref != 'refs/heads/main' && github.ref != 'refs/heads/dev' }}
 
       - name: Build with Gradle
         run: ./gradlew build -x test
 
@@ -38,7 +38,6 @@ dependencies {
     // DevTools
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
-//    developmentOnly 'org.springframework.boot:spring-boot-devtools'
     implementation 'org.mapstruct:mapstruct:1.5.5.Final'
     annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final'
 
@@ -107,7 +106,7 @@ dependencies {
     // redis
     implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 
-    // jackon
+    // jackson
     implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.15.0'
 
     // monitoring
@@ -125,8 +124,12 @@ dependencies {
     // Swagger
     implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
 
-    // Slack
-    implementation 'com.slack.api:slack-api-client:1.45.3'
+    // Flyway
+    implementation 'org.flywaydb:flyway-core'
+    implementation 'org.flywaydb:flyway-mysql'
+
+    // WebFlux
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
 }
 
 configurations {
@@ -139,7 +142,9 @@ configurations {
 def jacocoExcludes = [
         '**/Q*',      // QueryDSL Q*
         '**/exception/**',
-        '**/dto/**'
+        '**/dto/**',
+        '**/controller/**',
+        '**/tempapply/**'
 ]
 
 test {
 
@@ -15,7 +15,7 @@ cp $PROJECT_ROOT/build/libs/ject-home.jar $JAR_FILE
 
 # jar 파일 실행
 echo "$TIME_NOW > $JAR_FILE 파일 실행" >> $DEPLOY_LOG
-nohup java -Dspring.profiles.active=prod -jar $JAR_FILE > $APP_LOG 2> $ERROR_LOG &
+nohup java -Dspring.profiles.active=dev -jar $JAR_FILE > $APP_LOG 2> $ERROR_LOG &
 
 CURRENT_PID=$(pgrep -f $JAR_FILE)
 echo "$TIME_NOW > 실행된 프로세스 아이디 $CURRENT_PID 입니다." >> $DEPLOY_LOG
@@ -1,7 +1,13 @@
 package org.ject.support.common.exception;
 
+import org.springframework.http.HttpStatus;
+
 public interface ErrorCode {
     String name();
+
+    HttpStatus getHttpStatus();
+
     String getCode();
+
     String getMessage();
 }
@@ -2,25 +2,36 @@
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.CONFLICT;
+import static org.springframework.http.HttpStatus.FORBIDDEN;
+import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR;
+import static org.springframework.http.HttpStatus.METHOD_NOT_ALLOWED;
+import static org.springframework.http.HttpStatus.NOT_FOUND;
+import static org.springframework.http.HttpStatus.UNAUTHORIZED;
 
 @Getter
 @AllArgsConstructor
 public enum GlobalErrorCode implements ErrorCode {
-    UNSUPPORTED_PARAMETER_TYPE("G-01", "Unsupported parameter type"),
-    RESOURCE_NOT_FOUND("G-02", "Resource not found"),
-    METHOD_NOT_ALLOWED("G-03", "Method not allowed"),
-    TEMPLATE_NOT_FOUND("G-04", "Template file not found"),
-    JSON_MARSHALLING_FAILURE("G-05", "Json marshalling failure"),
-    EMPTY_ACCESS_TOKEN("G-06", "Empty access token"),
-    INVALID_ACCESS_TOKEN("G-07", "Invalid access token"),
-    INVALID_PERMISSION("G-08", "Invalid permission"),
-    AUTHENTICATION_REQUIRED("G-09", "Authentication is required"),
-    INTERNAL_SERVER_ERROR("G-10", "Internal server error"),
-    OVER_PERIOD("G-11", "모집 기간이 아닙니다."),
-    MISS_REQUIRED_REQUEST_PARAMETER("G-12", "Missing required parameter"),
-    MISS_REQUEST_BODY("G-13", "Missing request body"),
-    MISS_REQUIRED_JOB_FAMILY_PARAMETER("G-14", "Missing required JobFamily parameter"),;
+    UNSUPPORTED_PARAMETER_TYPE(BAD_REQUEST, "GLOBAL-1", "Unsupported parameter type"),
+    RESOURCE_NOT_FOUND(NOT_FOUND, "GLOBAL-2", "Resource not found"),
+    TEMPLATE_NOT_FOUND(NOT_FOUND, "GLOBAL-3", "Template file not found"),
+    JSON_MARSHALLING_FAILURE(INTERNAL_SERVER_ERROR, "GLOBAL-4", "Json marshalling failure"),
+    EMPTY_ACCESS_TOKEN(UNAUTHORIZED, "GLOBAL-5", "Empty access token"),
+    INVALID_ACCESS_TOKEN(UNAUTHORIZED, "GLOBAL-6", "Invalid access token"),
+    INVALID_PERMISSION(FORBIDDEN, "GLOBAL-7", "Invalid permission"),
+    AUTHENTICATION_REQUIRED(UNAUTHORIZED, "GLOBAL-8", "Authentication is required"),
+    OVER_PERIOD(CONFLICT, "GLOBAL-9", "모집 기간이 아닙니다."),
+    MISS_REQUIRED_REQUEST_PARAMETER(BAD_REQUEST, "GLOBAL-10", "Missing required parameter"),
+    MISS_REQUEST_BODY(BAD_REQUEST, "GLOBAL-11", "Missing request body"),
+    MISS_REQUIRED_JOB_FAMILY_PARAMETER(BAD_REQUEST, "GLOBAL-12", "Missing required JobFamily parameter"),
+    AUTHENTICATION_PROCESSING_ERROR(INTERNAL_SERVER_ERROR, "GLOBAL-13", "인증 처리 중 오류가 발생했습니다."),
+    REQUEST_METHOD_NOT_ALLOWED(METHOD_NOT_ALLOWED, "GLOBAL-14", "Method not allowed"),
+    METHOD_VALIDATION_FAILED(BAD_REQUEST, "GLOBAL-15", "Method validation failed");
 
+    private final HttpStatus httpStatus;
     private final String code;
     private final String message;
 }
@@ -1,96 +1,148 @@
 package org.ject.support.common.exception;
 
 import lombok.extern.slf4j.Slf4j;
+import org.ject.support.common.response.ErrorResponse;
+import org.ject.support.external.email.exception.RateLimitException;
+import org.springframework.context.MessageSourceResolvable;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.method.annotation.HandlerMethodValidationException;
 import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
 import org.springframework.web.servlet.resource.NoResourceFoundException;
 
+import java.util.List;
+
 @Slf4j
 @RestControllerAdvice
-public class GlobalExceptionHandler{
+public class GlobalExceptionHandler {
     private static final String LOG_FORMAT = "\nException Class = {}\nResponse Code = {}\nMessage = {}";
 
     /**
      * 비즈니스 로직에서 정의한 예외가 발생할 때 처리
      */
     @ExceptionHandler(BusinessException.class)
-    protected ErrorCode handleBusinessException(BusinessException e) {
+    protected ErrorResponse handleBusinessException(BusinessException e) {
         ErrorCode errorCode = e.getErrorCode();
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
+    }
+
+    /**
+     * 횟수 제한 예외 처리 (Retry-After 헤더 추가)
+     */
+    @ExceptionHandler(RateLimitException.class)
+    protected ResponseEntity<ErrorResponse> handleRateLimitException(RateLimitException e) {
+        ErrorCode errorCode = e.getErrorCode();
+        logException(e, errorCode);
+        
+        return ResponseEntity
+                .status(HttpStatus.TOO_MANY_REQUESTS)
+                .header("Retry-After", String.valueOf(e.getRetryAfter()))
+                .body(ErrorResponse.of(errorCode));
     }
 
     /**
      * 애플리케이션 전역에 문제되는 예외가 발생할 때 처리
      */
     @ExceptionHandler(GlobalException.class)
-    protected ErrorCode handleGlobalException(GlobalException e) {
+    protected ErrorResponse handleGlobalException(GlobalException e) {
         GlobalErrorCode errorCode = e.getErrorCode();
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
     }
 
     /**
      * 요청 매개변수의 타입이 잘못된 경우 발생
      */
     @ExceptionHandler(MethodArgumentTypeMismatchException.class)
-    protected ErrorCode handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e) {
+    protected ErrorResponse handleMethodArgumentTypeMismatchException(MethodArgumentTypeMismatchException e) {
         GlobalErrorCode errorCode = GlobalErrorCode.UNSUPPORTED_PARAMETER_TYPE;
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
     }
 
     /**
      * 잘못된 HTTP Method의 API를 호출할 때 발생
      */
     @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
-    protected ErrorCode handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
-        GlobalErrorCode errorCode = GlobalErrorCode.METHOD_NOT_ALLOWED;
+    protected ErrorResponse handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
+        GlobalErrorCode errorCode = GlobalErrorCode.REQUEST_METHOD_NOT_ALLOWED;
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
     }
 
     /**
      * 존재하지 않는 API를 호출할 때 발생
      */
     @ExceptionHandler(NoResourceFoundException.class)
-    protected ErrorCode handleNoResourceFoundException(NoResourceFoundException e) {
+    protected ErrorResponse handleNoResourceFoundException(NoResourceFoundException e) {
         GlobalErrorCode errorCode = GlobalErrorCode.RESOURCE_NOT_FOUND;
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
     }
 
     /**
      * 필수 파라미터가 누락되었을 때 발생
      */
     @ExceptionHandler(MissingServletRequestParameterException.class)
-    protected ErrorCode handleMissingServletRequestParameterException(MissingServletRequestParameterException e) {
+    protected ErrorResponse handleMissingServletRequestParameterException(MissingServletRequestParameterException e) {
         GlobalErrorCode errorCode = GlobalErrorCode.MISS_REQUIRED_REQUEST_PARAMETER;
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
     }
 
     /**
      * 요청 body가 누락되었을 때 발생
      */
     @ExceptionHandler(HttpMessageNotReadableException.class)
-    protected ErrorCode handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
+    protected ErrorResponse handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
         GlobalErrorCode errorCode = GlobalErrorCode.MISS_REQUEST_BODY;
         logException(e, errorCode);
-        return errorCode;
+        return ErrorResponse.of(errorCode);
+    }
+
+    /**
+     * 요청 파라미터에 대한 유효성 검증 실패 시 발생
+     */
+    @ExceptionHandler(HandlerMethodValidationException.class)
+    public ErrorResponse handleHandlerMethodValidationException(HandlerMethodValidationException e) {
+        GlobalErrorCode errorCode = GlobalErrorCode.METHOD_VALIDATION_FAILED;
+        logException(e, errorCode);
+
+        List<String> errorMessages = e.getAllErrors().stream()
+                .map(MessageSourceResolvable::getDefaultMessage)
+                .toList();
+
+        return ErrorResponse.of(errorCode, errorMessages);
+    }
+
+    /**
+     * RequestBody에 대한 유효성 검증 실패 시 발생
+     */
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ErrorResponse handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        GlobalErrorCode errorCode = GlobalErrorCode.METHOD_VALIDATION_FAILED;
+        logException(e, errorCode);
+
+        List<String> errorMessages = e.getAllErrors().stream()
+                .map(MessageSourceResolvable::getDefaultMessage)
+                .toList();
+
+        return ErrorResponse.of(errorCode, errorMessages);
     }
 
     /**
      * 예외 정보를 로깅 (ErrorCode 메시지 사용)
      */
     private void logException(final Exception e, final ErrorCode errorCode) {
-        log.error(LOG_FORMAT,
-                e.getClass(),
-                errorCode.getCode(),
-                errorCode.getMessage());
+        log.error(LOG_FORMAT, e.getClass(), errorCode.getCode(), errorCode.getMessage());
     }
 }
@@ -0,0 +1,34 @@
+package org.ject.support.common.response;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import org.ject.support.common.exception.ErrorCode;
+import org.springframework.http.HttpStatus;
+
+import java.util.List;
+
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class ErrorResponse {
+    private ErrorCode code;
+    private List<String> messages;
+
+    public static ErrorResponse of(ErrorCode code) {
+        return new ErrorResponse(code, List.of(code.getMessage()));
+    }
+
+    public static ErrorResponse of(ErrorCode code, List<String> messages) {
+        return new ErrorResponse(code, messages);
+    }
+
+    public HttpStatus getStatus() {
+        return code.getHttpStatus();
+    }
+
+    public String getCode() {
+        return code.getCode();
+    }
+
+    public List<String> getMessages() {
+        return messages;
+    }
+}
@@ -1,6 +1,5 @@
 package org.ject.support.common.response;
 
-import org.ject.support.common.exception.ErrorCode;
 import org.springframework.core.MethodParameter;
 import org.springframework.http.MediaType;
 import org.springframework.http.converter.HttpMessageConverter;
@@ -30,8 +29,9 @@ public Object beforeBodyWrite(final Object body, final MethodParameter returnTyp
         }
 
         // Error Response 반환
-        if (body instanceof ErrorCode errorCode) {
-            return new ApiResponse<>(errorCode.getCode(),errorCode.getMessage());
+        if (body instanceof ErrorResponse errorResponse) {
+            response.setStatusCode(errorResponse.getStatus());
+            return new ApiResponse<>(errorResponse.getCode(), errorResponse.getMessages());
         }
 
         // Success Response 반환
 
@@ -5,6 +5,7 @@
 import lombok.RequiredArgsConstructor;
 import org.ject.support.common.security.jwt.JwtCookieProvider;
 import org.ject.support.common.security.jwt.JwtTokenProvider;
+import org.springframework.http.HttpHeaders;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
 import org.springframework.stereotype.Component;
@@ -24,8 +25,8 @@ public void onAuthenticationSuccess(HttpServletRequest request, HttpServletRespo
         String accessToken = jwtTokenProvider.createAccessToken(authentication, customUserDetails.getMemberId());
         String refreshToken = jwtTokenProvider.createRefreshToken(authentication, customUserDetails.getMemberId());
 
-        response.addCookie(jwtCookieProvider.createRefreshCookie(refreshToken));
-        response.addCookie(jwtCookieProvider.createAccessCookie(accessToken));
+        response.addHeader(HttpHeaders.SET_COOKIE, jwtCookieProvider.createRefreshCookie(refreshToken).toString());
+        response.addHeader(HttpHeaders.SET_COOKIE, jwtCookieProvider.createAccessCookie(accessToken).toString());
     }
 
     /**
@@ -36,7 +37,7 @@ public void onAuthenticationSuccess(HttpServletRequest request, HttpServletRespo
     public void onAuthenticationSuccess(HttpServletResponse response, String email) {
         String verificationToken = jwtTokenProvider.createVerificationToken(email);
 
-        response.addCookie(jwtCookieProvider.createVerificationCookie(verificationToken));
+        response.addHeader(HttpHeaders.SET_COOKIE, jwtCookieProvider.createVerificationCookie(verificationToken).toString());
     }
 
     /**
@@ -48,6 +49,6 @@ public void onAuthenticationSuccess(HttpServletResponse response, String email)
     public void onAuthenticationSuccess(HttpServletResponse response, String refreshToken, Long memberId) {
         String newAccessToken = jwtTokenProvider.reissueAccessToken(refreshToken, memberId);
 
-        response.addCookie(jwtCookieProvider.createAccessCookie(newAccessToken));
+        response.addHeader(HttpHeaders.SET_COOKIE, jwtCookieProvider.createAccessCookie(newAccessToken).toString());
     }
 }