Add/#79 add exception

src/main/java/org/sophy/sophy/common/advice/ControllerExceptionAdvice.java

@@ -1,11 +1,14 @@
 package org.sophy.sophy.common.advice;
 
+import com.fasterxml.jackson.core.JsonParseException;
 import com.fasterxml.jackson.databind.exc.InvalidFormatException;
 import io.jsonwebtoken.ExpiredJwtException;
+import io.jsonwebtoken.security.SignatureException;
 import io.lettuce.core.RedisCommandExecutionException;
 import org.sophy.sophy.common.dto.ApiResponseDto;
 import org.sophy.sophy.exception.ErrorStatus;
 import org.sophy.sophy.exception.model.SophyException;
+import org.sophy.sophy.exception.model.SophyJwtException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.MethodArgumentNotValidException;
@@ -21,42 +24,55 @@ public class ControllerExceptionAdvice {
      */
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    protected ApiResponseDto handleMethodArgumentNotValidException(
-        final MethodArgumentNotValidException e) {
+    protected ApiResponseDto<?> handleMethodArgumentNotValidException() {
         return ApiResponseDto.error(ErrorStatus.VALIDATION_REQUEST_MISSING_EXCEPTION);
     }
 
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     @ExceptionHandler(RedisCommandExecutionException.class)
-    protected ApiResponseDto handleRedisCommandExecutionException(
-        final RedisCommandExecutionException e) {
+    protected ApiResponseDto<?> handleRedisCommandExecutionException() {
         return ApiResponseDto.error(ErrorStatus.INVALID_TOKEN_INFO_EXCEPTION);
     }
 
-    @ResponseStatus(HttpStatus.UNAUTHORIZED)
-    @ExceptionHandler(ExpiredJwtException.class)
-    protected ApiResponseDto handleExpiredRefreshTokenException(final ExpiredJwtException e) {
-        return ApiResponseDto.error(ErrorStatus.REFRESH_TOKEN_TIME_EXPIRED_EXCEPTION);
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler(IllegalArgumentException.class)
+    protected ApiResponseDto<?> handleIllegalArgumentException() {
+        return ApiResponseDto.error(ErrorStatus.ILLEGAL_ARGUMENT_EXCEPTION);
     }
 
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     @ExceptionHandler(InvalidFormatException.class)
-    protected ApiResponseDto handleInvalidFormatException(final InvalidFormatException e) {
+    protected ApiResponseDto<?> handleInvalidFormatException() {
         return ApiResponseDto.error(ErrorStatus.INVALID_FORMAT_EXCEPTION);
     }
 
-//    @ResponseStatus(HttpStatus.NOT_FOUND)
-//    @ExceptionHandler(IllegalArgumentException.class)
-//    protected ApiResponseDto handleIllegalArgumentException(final IllegalArgumentException e) {
-//        return ApiResponseDto.error(ErrorStatus.NOT_FOUND_CITY_EXCEPTION);
-//    }
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    @ExceptionHandler(value = {SignatureException.class, JsonParseException.class})
+    protected ApiResponseDto<?> handleSignatureException() {
+        return ApiResponseDto.error(401, "Jwt 토큰의 형식이 잘못되었습니다.");
+    }
+
+    /*
+    401 UN_AUTHORIZED
+     */
+    @ResponseStatus(HttpStatus.UNAUTHORIZED)
+    @ExceptionHandler(ExpiredJwtException.class)
+    protected ApiResponseDto<?> handleExpiredRefreshTokenException() {
+        return ApiResponseDto.error(ErrorStatus.REFRESH_TOKEN_TIME_EXPIRED_EXCEPTION);
+    }
 
     /**
      * Sopt custom error
      */
     @ExceptionHandler(SophyException.class)
-    protected ResponseEntity<ApiResponseDto> handleSophyException(SophyException e) {
+    protected ResponseEntity<ApiResponseDto<?>> handleSophyException(SophyException e) {
         return ResponseEntity.status(e.getHttpStatus())
             .body(ApiResponseDto.error(e.getErrorStatus(), e.getMessage()));
     }
+
+    @ExceptionHandler(SophyJwtException.class)
+    protected ResponseEntity<ApiResponseDto<?>> handleSophyJwtException(SophyJwtException e) {
+        return ResponseEntity.status(e.getHttpStatus())
+            .body(ApiResponseDto.error(e.getHttpStatus(), e.getMessage()));
+    }
 }

src/main/java/org/sophy/sophy/common/dto/ApiResponseDto.java

@@ -16,21 +16,25 @@ public class ApiResponseDto<T> {
     private final String message;
     private T data;
 
-    public static ApiResponseDto success(SuccessStatus successStatus) {
+    public static ApiResponseDto<?> success(SuccessStatus successStatus) {
         return new ApiResponseDto<>(successStatus.getHttpStatus().value(),
             successStatus.getMessage());
     }
 
     public static <T> ApiResponseDto<T> success(SuccessStatus successStatus, T data) {
-        return new ApiResponseDto<T>(successStatus.getHttpStatus().value(),
+        return new ApiResponseDto<>(successStatus.getHttpStatus().value(),
             successStatus.getMessage(), data);
     }
 
-    public static ApiResponseDto error(ErrorStatus errorStatus) {
+    public static ApiResponseDto<?> error(ErrorStatus errorStatus) {
         return new ApiResponseDto<>(errorStatus.getHttpStatus().value(), errorStatus.getMessage());
     }
 
-    public static ApiResponseDto error(ErrorStatus errorStatus, String message) {
+    public static ApiResponseDto<?> error(ErrorStatus errorStatus, String message) {
         return new ApiResponseDto<>(errorStatus.getHttpStatusCode(), message);
     }
+
+    public static ApiResponseDto<?> error(Integer httpStatus, String message) {
+        return new ApiResponseDto<>(httpStatus, message);
+    }
 }

src/main/java/org/sophy/sophy/exception/ErrorStatus.java

@@ -17,6 +17,7 @@ public enum ErrorStatus {
     INVALID_MULTIPART_EXTENSION_EXCEPTION(HttpStatus.BAD_REQUEST, "허용되지 않은 타입의 파일입니다."),
     INVALID_TOKEN_INFO_EXCEPTION(HttpStatus.BAD_REQUEST, "토큰 혹은 만료시간 설정이 잘못되었습니다."),
     INVALID_FORMAT_EXCEPTION(HttpStatus.BAD_REQUEST, "잘못된 형식입니다."),
+    ILLEGAL_ARGUMENT_EXCEPTION(HttpStatus.BAD_REQUEST, "잘못된 인자로 요청하였습니다."),
 
     /**
      * 401 UNAUTHORIZED

src/main/java/org/sophy/sophy/exception/model/SophyJwtException.java

@@ -0,0 +1,16 @@
+package org.sophy.sophy.exception.model;
+
+import io.jsonwebtoken.JwtException;
+import org.springframework.http.HttpStatus;
+
+public class SophyJwtException extends JwtException {
+    private final HttpStatus httpStatus;
+
+    public SophyJwtException(HttpStatus httpStatus, String message) {
+        super(message);
+        this.httpStatus = httpStatus;
+    }
+    public Integer getHttpStatus() {
+        return httpStatus.value();
+    }
+}

src/main/java/org/sophy/sophy/jwt/TokenProvider.java

@@ -1,11 +1,27 @@
 package org.sophy.sophy.jwt;
 
-import io.jsonwebtoken.*;
+import static org.sophy.sophy.jwt.JwtFilter.AUTHORIZATION_HEADER;
+import static org.sophy.sophy.jwt.JwtFilter.BEARER_PREFIX;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.ExpiredJwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.MalformedJwtException;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.UnsupportedJwtException;
 import io.jsonwebtoken.io.Decoders;
 import io.jsonwebtoken.security.Keys;
+import java.security.Key;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.stream.Collectors;
+import javax.servlet.http.HttpServletRequest;
 import lombok.extern.slf4j.Slf4j;
 import org.sophy.sophy.controller.dto.response.TokenDto;
+import org.sophy.sophy.exception.model.SophyJwtException;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.GrantedAuthority;
@@ -15,26 +31,14 @@
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
 
-import javax.servlet.http.HttpServletRequest;
-import java.security.Key;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Date;
-import java.util.stream.Collectors;
-
-import static org.sophy.sophy.jwt.JwtFilter.AUTHORIZATION_HEADER;
-import static org.sophy.sophy.jwt.JwtFilter.BEARER_PREFIX;
-
 
 @Slf4j
 @Component
 public class TokenProvider {
 
+    public static final String REFRESH_HEADER = "Refresh";
     private static final String AUTHORITIES_KEY = "auth";
     private static final String BEARER_TYPE = "Bearer";
-    public static final String REFRESH_HEADER = "Refresh";
-
-
     private static final Long ACCESS_TOKEN_EXPIRE_TIME = 1000 * 60L;
     private static final Long REFRESH_TOKEN_EXPIRE_TIME = 1000 * 60 * 60 * 24 * 7L;
     private final Key key;
@@ -85,7 +89,7 @@ public Authentication getAuthentication(String accessToken) {
         Claims claims = parseClaims(accessToken);
 
         if (claims.get(AUTHORITIES_KEY) == null) {
-            throw new JwtException("권한 정보가 없는 토큰입니다.");
+            throw new SophyJwtException(HttpStatus.UNAUTHORIZED, "권한 정보가 없는 토큰입니다.");
         }
 
         //클레임에서 권한 정보 가져오기
@@ -120,15 +124,16 @@ public boolean validateToken(String token) {
                 .build()
                 .parseClaimsJws(token);
             return true;
-        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) { //토큰 형식이 잘못됨
+        } catch (io.jsonwebtoken.security.SecurityException |
+                 MalformedJwtException e) { //토큰 형식이 잘못됨
             log.info("잘못된 JWT 서명입니다.");
-            throw new JwtException("잘못된 JWT 서명입니다.");
+            throw new SophyJwtException(HttpStatus.UNAUTHORIZED, "잘못된 JWT 서명입니다.");
         } catch (UnsupportedJwtException e) { //이 버전에서 지원하지 않는 JWT 토큰
             log.info("지원되지 않는 JWT 토큰입니다.");
-            throw new JwtException("지원되지 않는 JWT 토큰입니다.");
+            throw new SophyJwtException(HttpStatus.UNAUTHORIZED, "지원되지 않는 JWT 토큰입니다.");
         } catch (IllegalStateException e) { //토큰의 형식이 잘못됨
             log.info("JWT 토큰이 잘못되었습니다.");
-            throw new JwtException("JWT 토큰이 잘못되었습니다.");
+            throw new SophyJwtException(HttpStatus.UNAUTHORIZED, "JWT 토큰이 잘못되었습니다.");
         }
     }