[그리디] 김민욱 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,14 +1,75 @@
 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 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<Void> handleRuntimeException(Exception e) {
+    public ResponseEntity<ErrorResponse> handleException(Exception e) {
         e.printStackTrace();
-        return ResponseEntity.badRequest().build();
+        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;
+
+        public ErrorResponse(int statusCode, String message) {
+            this.statusCode = statusCode;
+            this.message = 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

@@ -0,0 +1,31 @@
+package roomescape;
+
+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.AdminInterceptor;
+import roomescape.auth.AuthUserArgumentResolver;
+
+import java.util.List;
+
+@Configuration // Spring MVC 설정을 추가함
+public class WebConfig implements WebMvcConfigurer {
+    private final AuthUserArgumentResolver authUserArgumentResolver;
+    private final AdminInterceptor adminInterceptor;
+
+    public WebConfig(AuthUserArgumentResolver authUserArgumentResolver, AdminInterceptor adminInterceptor) {
+        this.authUserArgumentResolver = authUserArgumentResolver;
+        this.adminInterceptor = adminInterceptor;
+    }
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(authUserArgumentResolver);
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(adminInterceptor);
+    }
+}

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

@@ -0,0 +1,47 @@
+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.AuthenticationException;
+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;
+        }
+
+        try {
+            String token = authCookieProvider.extractAccessToken(request);
+            LoginMemberInfo loginMember = memberService.checkLogin(token);
+            if (MemberRole.ADMIN == loginMember.role()) {
+                return true;
+            }
+            throw new AuthorizationException();
+        } catch (AuthorizationException e) {
+            throw e;
+        } catch (RuntimeException e) {
+            throw new AuthenticationException();
+        }
+    }
+
+    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

@@ -0,0 +1,88 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.stereotype.Component;
+import roomescape.exception.AuthenticationException;
+
+@Component
+public class AuthCookieProvider {
+    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) {
+        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() {
+        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 (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/AuthUser.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.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuthUser {
+}

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

@@ -0,0 +1,78 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.core.MethodParameter;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+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 AuthUserArgumentResolver implements HandlerMethodArgumentResolver {
+    private final MemberService memberService;
+    private final AuthCookieProvider authCookieProvider;
+
+    public AuthUserArgumentResolver(MemberService memberService, AuthCookieProvider authCookieProvider) {
+        this.memberService = memberService;
+        this.authCookieProvider = authCookieProvider;
+    }
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(AuthUser.class)
+                && (LoginMemberInfo.class.isAssignableFrom(parameter.getParameterType())
+                || isOptionalLoginMemberInfo(parameter));
+    }
+
+
+    @Override
+    public Object resolveArgument(
+            MethodParameter parameter,
+            ModelAndViewContainer mavContainer,
+            NativeWebRequest webRequest,
+            WebDataBinderFactory binderFactory
+    ) {
+        boolean optional = isOptionalLoginMemberInfo(parameter);
+        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
+        if (request == null) {
+            return handleAuthenticationFailure(optional);
+        }
+
+        try {
+            String token = authCookieProvider.extractAccessToken(request);
+            LoginMemberInfo loginMember = memberService.checkLogin(token);
+            if (optional) {
+                return Optional.of(loginMember);
+            }
+            return loginMember;
+        } catch (RuntimeException e) {
+            return handleAuthenticationFailure(optional);
+        }
+    }
+
+    private Object handleAuthenticationFailure(boolean optional) {
+        if (optional) {
+            return Optional.empty();
+        }
+        throw new AuthenticationException();
+    }
+
+    private boolean isOptionalLoginMemberInfo(MethodParameter parameter) {
+        if (!Optional.class.isAssignableFrom(parameter.getParameterType())) {
+            return false;
+        }
+        Type genericParameterType = parameter.getGenericParameterType();
+        if (!(genericParameterType instanceof ParameterizedType parameterizedType)) {
+            return false;
+        }
+        Type actualType = parameterizedType.getActualTypeArguments()[0];
+        return LoginMemberInfo.class.getName().equals(actualType.getTypeName());
+    }
+}