[그리디] 김민욱 Spring Data JPA 4, 5단계 제출합니다.

build.gradle

@@ -16,6 +16,10 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation 'org.springframework.boot:spring-boot-starter-jdbc'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
 
     implementation 'dev.akkinoc.spring.boot:logback-access-spring-boot-starter:4.0.0'
 

src/main/java/roomescape/ExceptionController.java

@@ -1,24 +1,68 @@
 package roomescape;
 
+import lombok.Getter;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import roomescape.exception.AuthenticationException;
+import roomescape.exception.AuthorizationException;
+import roomescape.exception.ConflictException;
+import roomescape.exception.ErrorCode;
+import roomescape.exception.NotFoundException;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 
-@ControllerAdvice
+@ControllerAdvice // 아 컨트롤러에서 발생한 예외를 가로챔 ~ ㅋ
 public class ExceptionController {
+    private static final Logger log = LoggerFactory.getLogger(ExceptionController.class);
+
     @ExceptionHandler(AuthenticationException.class)
     public ResponseEntity<ErrorResponse> handleAuthenticationException(AuthenticationException e) {
-        return ResponseEntity.status(401)
-                .body(new ErrorResponse(401, "로그인이 필요합니다."));
+        return error(e.getErrorCode());
+    }
+
+    @ExceptionHandler(AuthorizationException.class)
+    public ResponseEntity<ErrorResponse> handleAuthorizationException(AuthorizationException e) {
+        return error(e.getErrorCode());
+    }
+
+    @ExceptionHandler(NotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFoundException(NotFoundException e) {
+        log.warn("Resource not found: {}", e.getMessage());
+        return error(e.getErrorCode());
+    }
+
+    @ExceptionHandler({ConflictException.class, DataIntegrityViolationException.class})
+    public ResponseEntity<ErrorResponse> handleConflictException(Exception e) {
+        if (e instanceof ConflictException conflictException) {
+            return error(conflictException.getErrorCode());
+        }
+        return error(ErrorCode.CONFLICT_REQUEST);
+    }
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<ErrorResponse> handleIllegalArgumentException(IllegalArgumentException e) {
+        return error(HttpStatus.BAD_REQUEST, e.getMessage());
     }
 
     @ExceptionHandler(Exception.class)
-    public ResponseEntity<ErrorResponse> handleRuntimeException(Exception e) {
+    public ResponseEntity<ErrorResponse> handleException(Exception e) {
         e.printStackTrace();
-        return ResponseEntity.badRequest()
-                .body(new ErrorResponse(400, "잘못된 요청입니다."));
+        return error(ErrorCode.INTERNAL_SERVER_ERROR);
+    }
+
+    private ResponseEntity<ErrorResponse> error(ErrorCode errorCode) {
+        return error(errorCode.getStatus(), errorCode.getMessage());
+    }
+
+    private ResponseEntity<ErrorResponse> error(HttpStatus status, String message) {
+        return ResponseEntity.status(status)
+                .body(new ErrorResponse(status.value(), message));
     }
 
+    @Getter
     public static class ErrorResponse {
         private final int statusCode;
         private final String message;
@@ -27,13 +71,5 @@ public ErrorResponse(int statusCode, String message) {
             this.statusCode = statusCode;
             this.message = message;
         }
-
-        public int getStatusCode() {
-            return statusCode;
-        }
-
-        public String getMessage() {
-            return message;
-        }
     }
 }

src/main/java/roomescape/PageController.java

@@ -2,25 +2,30 @@
 
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
+import roomescape.auth.AdminOnly;
 
 @Controller
 public class PageController {
     @GetMapping("/admin")
+    @AdminOnly
     public String admin() {
         return "admin/index";
     }
 
     @GetMapping("/admin/reservation")
+    @AdminOnly
     public String adminReservation() {
         return "admin/reservation";
     }
 
     @GetMapping("/admin/theme")
+    @AdminOnly
     public String adminTheme() {
         return "admin/theme";
     }
 
     @GetMapping("/admin/time")
+    @AdminOnly
     public String adminTime() {
         return "admin/time";
     }

src/main/java/roomescape/WebConfig.java

@@ -2,22 +2,30 @@
 
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
-import roomescape.auth.LoginMemberArgumentResolver;
+import roomescape.auth.AdminInterceptor;
+import roomescape.auth.AuthUserArgumentResolver;
 
 import java.util.List;
 
-@Configuration
+@Configuration // Spring MVC 설정을 추가함
 public class WebConfig implements WebMvcConfigurer {
-    private final LoginMemberArgumentResolver loginMemberArgumentResolver;
+    private final AuthUserArgumentResolver authUserArgumentResolver;
+    private final AdminInterceptor adminInterceptor;
 
-    public WebConfig(LoginMemberArgumentResolver loginMemberArgumentResolver) {
-        this.loginMemberArgumentResolver = loginMemberArgumentResolver;
+    public WebConfig(AuthUserArgumentResolver authUserArgumentResolver, AdminInterceptor adminInterceptor) {
+        this.authUserArgumentResolver = authUserArgumentResolver;
+        this.adminInterceptor = adminInterceptor;
     }
 
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
-        resolvers.add(loginMemberArgumentResolver);
-        // 로그인에 이 resolver를 사용해라
+        resolvers.add(authUserArgumentResolver);
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(adminInterceptor);
     }
 }

src/main/java/roomescape/auth/AdminInterceptor.java

@@ -0,0 +1,40 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.stereotype.Component;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.HandlerInterceptor;
+import roomescape.exception.AuthorizationException;
+import roomescape.member.MemberService;
+import roomescape.member.MemberRole;
+
+@Component
+public class AdminInterceptor implements HandlerInterceptor {
+    private final AuthCookieProvider authCookieProvider;
+    private final MemberService memberService;
+
+    public AdminInterceptor(AuthCookieProvider authCookieProvider, MemberService memberService) {
+        this.authCookieProvider = authCookieProvider;
+        this.memberService = memberService;
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        if (!(handler instanceof HandlerMethod handlerMethod) || !hasAdminOnly(handlerMethod)) {
+            return true;
+        }
+
+        String token = authCookieProvider.extractAccessToken(request);
+        LoginMemberInfo loginMember = memberService.checkLogin(token);
+        if (MemberRole.ADMIN == loginMember.role()) {
+            return true;
+        }
+        throw new AuthorizationException();
+    }
+
+    private boolean hasAdminOnly(HandlerMethod handlerMethod) {
+        return handlerMethod.hasMethodAnnotation(AdminOnly.class)
+                || handlerMethod.getBeanType().isAnnotationPresent(AdminOnly.class);
+    }
+}

src/main/java/roomescape/auth/AdminOnly.java

@@ -0,0 +1,11 @@
+package roomescape.auth;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AdminOnly {
+}

src/main/java/roomescape/auth/AuthCookieProvider.java

@@ -3,39 +3,86 @@
 import jakarta.servlet.http.Cookie;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.stereotype.Component;
-import roomescape.AuthenticationException;
+import roomescape.exception.AuthenticationException;
 
 @Component
 public class AuthCookieProvider {
-    private static final String TOKEN_COOKIE_NAME = "token";
+    private static final String ACCESS_TOKEN_COOKIE_NAME = "accessToken";
+    private static final String REFRESH_TOKEN_COOKIE_NAME = "refreshToken";
+    private static final String LEGACY_TOKEN_COOKIE_NAME = "token";
     private static final String COOKIE_PATH = "/";
 
     public Cookie createLoginCookie(String token) {
-        Cookie cookie = new Cookie(TOKEN_COOKIE_NAME, token);
+        return createAccessTokenCookie(token);
+    }
+
+    public Cookie createAccessTokenCookie(String token) {
+        return createCookie(ACCESS_TOKEN_COOKIE_NAME, token);
+    }
+
+    public Cookie createRefreshTokenCookie(String token) {
+        return createCookie(REFRESH_TOKEN_COOKIE_NAME, token);
+    }
+
+    private Cookie createCookie(String name, String value) {
+        Cookie cookie = new Cookie(name, value);
         cookie.setHttpOnly(true);
         cookie.setPath(COOKIE_PATH);
         return cookie;
     }
 
     public Cookie createLogoutCookie() {
-        Cookie cookie = new Cookie(TOKEN_COOKIE_NAME, "");
+        return createLogoutCookie(LEGACY_TOKEN_COOKIE_NAME);
+    }
+
+    public Cookie createLogoutAccessTokenCookie() {
+        return createLogoutCookie(ACCESS_TOKEN_COOKIE_NAME);
+    }
+
+    public Cookie createLogoutRefreshTokenCookie() {
+        return createLogoutCookie(REFRESH_TOKEN_COOKIE_NAME);
+    }
+
+    private Cookie createLogoutCookie(String name) {
+        Cookie cookie = new Cookie(name, "");
         cookie.setHttpOnly(true);
         cookie.setPath(COOKIE_PATH);
         cookie.setMaxAge(0);
         return cookie;
     }
 
     public String extractToken(HttpServletRequest request) {
+        return extractAccessToken(request);
+    }
+
+    public String extractAccessToken(HttpServletRequest request) {
+        return extractToken(request, ACCESS_TOKEN_COOKIE_NAME, LEGACY_TOKEN_COOKIE_NAME);
+    }
+
+    public String extractRefreshToken(HttpServletRequest request) {
+        return extractToken(request, REFRESH_TOKEN_COOKIE_NAME);
+    }
+
+    private String extractToken(HttpServletRequest request, String... cookieNames) {
         Cookie[] cookies = request.getCookies();
         if (cookies == null) {
             throw new AuthenticationException();
         }
 
         for (Cookie cookie : cookies) {
-            if (TOKEN_COOKIE_NAME.equals(cookie.getName())) {
+            if (contains(cookieNames, cookie.getName())) {
                 return cookie.getValue();
             }
         }
         throw new AuthenticationException();
     }
+
+    private boolean contains(String[] values, String target) {
+        for (String value : values) {
+            if (value.equals(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }

src/main/java/roomescape/auth/LoginMember.java → src/main/java/roomescape/auth/AuthUser.java

@@ -7,5 +7,5 @@
 
 @Target(ElementType.PARAMETER)
 @Retention(RetentionPolicy.RUNTIME)
-public @interface LoginMember {
+public @interface AuthUser {
 }

src/main/java/roomescape/auth/LoginMemberArgumentResolver.java → src/main/java/roomescape/auth/AuthUserArgumentResolver.java

@@ -7,26 +7,26 @@
 import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.method.support.ModelAndViewContainer;
-import roomescape.AuthenticationException;
+import roomescape.exception.AuthenticationException;
 import roomescape.member.MemberService;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.Optional;
 
 @Component
-public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {
+public class AuthUserArgumentResolver implements HandlerMethodArgumentResolver {
     private final MemberService memberService;
     private final AuthCookieProvider authCookieProvider;
 
-    public LoginMemberArgumentResolver(MemberService memberService, AuthCookieProvider authCookieProvider) {
+    public AuthUserArgumentResolver(MemberService memberService, AuthCookieProvider authCookieProvider) {
         this.memberService = memberService;
         this.authCookieProvider = authCookieProvider;
     }
 
     @Override
     public boolean supportsParameter(MethodParameter parameter) {
-        return parameter.hasParameterAnnotation(LoginMember.class)
+        return parameter.hasParameterAnnotation(AuthUser.class)
                 && (LoginMemberInfo.class.isAssignableFrom(parameter.getParameterType())
                 || isOptionalLoginMemberInfo(parameter));
     }
@@ -46,13 +46,13 @@ public Object resolveArgument(
         }
 
         try {
-            String token = authCookieProvider.extractToken(request);
+            String token = authCookieProvider.extractAccessToken(request);
             LoginMemberInfo loginMember = memberService.checkLogin(token);
             if (optional) {
                 return Optional.of(loginMember);
             }
             return loginMember;
-        } catch (RuntimeException e) {
+        } catch (AuthenticationException e) {
             return handleAuthenticationFailure(optional);
         }
     }