refactor: @PageableDefault 및 페이지 검증 로직을 ArgumentResolver로 개선

src/main/java/com/example/solidconnection/admin/controller/AdminScoreController.java

@@ -10,17 +10,13 @@
 import com.example.solidconnection.admin.service.AdminGpaScoreService;
 import com.example.solidconnection.admin.service.AdminLanguageTestScoreService;
 import com.example.solidconnection.custom.response.PageResponse;
-import com.example.solidconnection.util.PagingUtils;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.web.PageableDefault;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.ModelAttribute;
-import org.springframework.web.bind.annotation.PatchMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -35,15 +31,15 @@ public class AdminScoreController {
     private final AdminGpaScoreService adminGpaScoreService;
     private final AdminLanguageTestScoreService adminLanguageTestScoreService;
 
-    // todo: 추후 커스텀 페이지 객체 & argumentResolver를 적용 필요
     @GetMapping("/gpas")
     public ResponseEntity<PageResponse<GpaScoreSearchResponse>> searchGpaScores(
             @Valid @ModelAttribute ScoreSearchCondition scoreSearchCondition,
-            @PageableDefault(page = 1) Pageable pageable
+            Pageable pageable
     ) {
-        PagingUtils.validatePage(pageable.getPageNumber(), pageable.getPageSize());
-        Pageable internalPageable = PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize());
-        Page<GpaScoreSearchResponse> page = adminGpaScoreService.searchGpaScores(scoreSearchCondition, internalPageable);
+        Page<GpaScoreSearchResponse> page = adminGpaScoreService.searchGpaScores(
+                scoreSearchCondition,
+                pageable
+        );
         return ResponseEntity.ok(PageResponse.of(page));
     }
 
@@ -56,15 +52,15 @@ public ResponseEntity<GpaScoreResponse> updateGpaScore(
         return ResponseEntity.ok(response);
     }
 
-    // todo: 추후 커스텀 페이지 객체 & argumentResolver를 적용 필요
     @GetMapping("/language-tests")
     public ResponseEntity<PageResponse<LanguageTestScoreSearchResponse>> searchLanguageTestScores(
             @Valid @ModelAttribute ScoreSearchCondition scoreSearchCondition,
-            @PageableDefault(page = 1) Pageable pageable
+            Pageable pageable
     ) {
-        PagingUtils.validatePage(pageable.getPageNumber(), pageable.getPageSize());
-        Pageable internalPageable = PageRequest.of(pageable.getPageNumber() - 1, pageable.getPageSize());
-        Page<LanguageTestScoreSearchResponse> page = adminLanguageTestScoreService.searchLanguageTestScores(scoreSearchCondition, internalPageable);
+        Page<LanguageTestScoreSearchResponse> page = adminLanguageTestScoreService.searchLanguageTestScores(
+                scoreSearchCondition,
+                pageable
+        );
         return ResponseEntity.ok(PageResponse.of(page));
     }
 

src/main/java/com/example/solidconnection/config/web/WebMvcConfig.java

@@ -1,7 +1,7 @@
 package com.example.solidconnection.config.web;
 
-
 import com.example.solidconnection.custom.resolver.AuthorizedUserResolver;
+import com.example.solidconnection.custom.resolver.CustomPageableHandlerMethodArgumentResolver;
 import com.example.solidconnection.custom.resolver.ExpiredTokenResolver;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Configuration;
@@ -16,12 +16,14 @@ public class WebMvcConfig implements WebMvcConfigurer {
 
     private final AuthorizedUserResolver authorizedUserResolver;
     private final ExpiredTokenResolver expiredTokenResolver;
+    private final CustomPageableHandlerMethodArgumentResolver customPageableHandlerMethodArgumentResolver;
 
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
         resolvers.addAll(List.of(
                 authorizedUserResolver,
-                expiredTokenResolver
+                expiredTokenResolver,
+                customPageableHandlerMethodArgumentResolver
         ));
     }
 }

src/main/java/com/example/solidconnection/custom/exception/ErrorCode.java

@@ -5,6 +5,9 @@
 import org.springframework.http.HttpStatus;
 
 import static com.example.solidconnection.application.service.ApplicationSubmissionService.APPLICATION_UPDATE_COUNT_LIMIT;
+import static com.example.solidconnection.custom.resolver.CustomPageableHandlerMethodArgumentResolver.MAX_SIZE;
+import static com.example.solidconnection.custom.resolver.CustomPageableHandlerMethodArgumentResolver.MIN_PAGE;
+import static com.example.solidconnection.custom.resolver.CustomPageableHandlerMethodArgumentResolver.MIN_SIZE;
 import static com.example.solidconnection.siteuser.service.SiteUserService.MIN_DAYS_BETWEEN_NICKNAME_CHANGES;
 
 @Getter
@@ -97,8 +100,8 @@ public enum ErrorCode {
     REJECTED_REASON_REQUIRED(HttpStatus.BAD_REQUEST.value(), "거절 사유가 필요합니다."),
 
     // page
-    INVALID_PAGE(HttpStatus.BAD_REQUEST.value(), "페이지 번호는 1 이상 50 이하만 가능합니다."),
-    INVALID_SIZE(HttpStatus.BAD_REQUEST.value(), "페이지 크기는 1 이상 50 이하만 가능합니다."),
+    INVALID_PAGE(HttpStatus.BAD_REQUEST.value(), "페이지 번호는 " + MIN_PAGE + " 이상만 가능합니다."),
+    INVALID_SIZE(HttpStatus.BAD_REQUEST.value(), "페이지 크기는 " + MIN_SIZE + " 이상 " + MAX_SIZE + " 이하만 가능합니다."),
 
     // general
     JSON_PARSING_FAILED(HttpStatus.BAD_REQUEST.value(), "JSON 파싱을 할 수 없습니다."),

src/main/java/com/example/solidconnection/custom/resolver/CustomPageableHandlerMethodArgumentResolver.java

@@ -0,0 +1,67 @@
+package com.example.solidconnection.custom.resolver;
+
+import com.example.solidconnection.custom.exception.CustomException;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.core.MethodParameter;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
+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.ModelAndViewContainer;
+
+import jakarta.servlet.http.HttpServletRequest;
+import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_PAGE;
+import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_SIZE;
+
+@Component
+public class CustomPageableHandlerMethodArgumentResolver extends PageableHandlerMethodArgumentResolver {
+
+    public static final int MIN_PAGE = 1;
+    public static final int MIN_SIZE = 1;
+    public static final int MAX_SIZE = 50;
+    private static final String PAGE_PARAMETER = "page";
+    private static final String SIZE_PARAMETER = "size";
+
+    public CustomPageableHandlerMethodArgumentResolver() {
+        setMaxPageSize(MAX_SIZE);
+        setOneIndexedParameters(true);
+        setFallbackPageable(PageRequest.of(0, 10));
+    }
+
+    @Override
+    public Pageable resolveArgument(MethodParameter methodParameter,
+                                    ModelAndViewContainer mavContainer,
+                                    NativeWebRequest webRequest,
+                                    WebDataBinderFactory binderFactory) {
+        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
+        if (request != null) {
+            validateParameters(request);
+        }
+        return super.resolveArgument(methodParameter, mavContainer, webRequest, binderFactory);
+    }
+
+    private void validateParameters(HttpServletRequest request) {
+        int page = extractIntParameter(request, PAGE_PARAMETER, 1);
+        int size = extractIntParameter(request, SIZE_PARAMETER, 10);
+        if (page < MIN_PAGE) {
+            throw new CustomException(INVALID_PAGE);
+        }
+        if (size < MIN_SIZE || size > MAX_SIZE) {
+            throw new CustomException(INVALID_SIZE);
+        }
+    }
+
+    private int extractIntParameter(HttpServletRequest request, String paramName, int defaultValue) {
+        String paramValue = request.getParameter(paramName);
+        if (StringUtils.isBlank(paramValue)) {
+            return defaultValue;
+        }
+        try {
+            return Integer.parseInt(paramValue);
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+}

src/test/java/com/example/solidconnection/custom/resolver/CustomPageableHandlerMethodArgumentResolverTest.java

@@ -0,0 +1,154 @@
+package com.example.solidconnection.custom.resolver;
+
+import com.example.solidconnection.custom.exception.CustomException;
+import com.example.solidconnection.support.TestContainerSpringBootTest;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.MethodParameter;
+import org.springframework.data.domain.Pageable;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.context.request.ServletWebRequest;
+
+import java.lang.reflect.Method;
+
+import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_PAGE;
+import static com.example.solidconnection.custom.exception.ErrorCode.INVALID_SIZE;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode;
+
+@TestContainerSpringBootTest
+@DisplayName("커스텀 페이지 요청 argument resolver 테스트")
+class CustomPageableHandlerMethodArgumentResolverTest {
+
+    private static final String PAGE_PARAMETER = "page";
+    private static final String SIZE_PARAMETER = "size";
+    private static final int DEFAULT_PAGE = 1;
+    private static final int DEFAULT_SIZE = 10;
+
+    @Autowired
+    private CustomPageableHandlerMethodArgumentResolver customPageableHandlerMethodArgumentResolver;
+
+    private MockHttpServletRequest request;
+    private NativeWebRequest webRequest;
+    private MethodParameter parameter;
+
+    @BeforeEach
+    void setUp() throws NoSuchMethodException {
+        request = new MockHttpServletRequest();
+        webRequest = new ServletWebRequest(request);
+        Method method = TestController.class.getMethod("pageableMethod", Pageable.class);
+        parameter = new MethodParameter(method, 0);
+    }
+
+    @Test
+    void 파라미터가_없으면_기본값을_사용한다() {
+        // when
+        Pageable pageable = customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null);
+
+        // then
+        assertThat(pageable.getPageNumber()).isEqualTo(DEFAULT_PAGE - 1);
+        assertThat(pageable.getPageSize()).isEqualTo(DEFAULT_SIZE);
+    }
+
+    @Test
+    void 유효한_파라미터가_있으면_해당_값을_사용한다() {
+        // given
+        int expectedPage = 2;
+        int expectedSize = 20;
+        request.setParameter(PAGE_PARAMETER, String.valueOf(expectedPage));
+        request.setParameter(SIZE_PARAMETER, String.valueOf(expectedSize));
+
+        // when
+        Pageable pageable = customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null);
+
+        // then
+        assertThat(pageable.getPageNumber()).isEqualTo(expectedPage - 1);
+        assertThat(pageable.getPageSize()).isEqualTo(expectedSize);
+    }
+
+    @Test
+    void 파라미터가_숫자가_아니면_기본값을_사용한다() {
+        // given
+        request.setParameter(PAGE_PARAMETER, "invalid");
+        request.setParameter(SIZE_PARAMETER, "invalid");
+
+        // when
+        Pageable pageable = customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null);
+
+        // then
+        assertThat(pageable.getPageNumber()).isEqualTo(DEFAULT_PAGE - 1);
+        assertThat(pageable.getPageSize()).isEqualTo(DEFAULT_SIZE);
+    }
+
+    @Test
+    void 페이지_파라미터가_최소값보다_작으면_예외_응답을_반환한다() {
+        // given
+        request.setParameter(PAGE_PARAMETER, "0");
+
+        // when & then
+        assertThatCode(() -> customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null))
+                .isInstanceOf(CustomException.class)
+                .hasMessage(INVALID_PAGE.getMessage());
+    }
+
+    @Test
+    void 페이지_파라미터가_음수이면_예외_응답을_반환한다() {
+        // given
+        request.setParameter(PAGE_PARAMETER, "-1");
+
+        // when & then
+        assertThatCode(() -> customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null))
+                .isInstanceOf(CustomException.class)
+                .hasMessage(INVALID_PAGE.getMessage());
+    }
+
+    @Test
+    void 사이즈_파라미터가_최소값보다_작으면_예외_응답을_반환한다() {
+        // given
+        request.setParameter(SIZE_PARAMETER, "0");
+
+        // when & then
+        assertThatCode(() -> customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null))
+                .isInstanceOf(CustomException.class)
+                .hasMessage(INVALID_SIZE.getMessage());
+    }
+
+    @Test
+    void 사이즈_파라미터가_최대값보다_크면_예외가_발생한다() {
+        // given
+        request.setParameter(SIZE_PARAMETER, String.valueOf(CustomPageableHandlerMethodArgumentResolver.MAX_SIZE + 1));
+
+        // when & then
+        assertThatCode(() -> customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null))
+                .isInstanceOf(CustomException.class)
+                .hasMessage(INVALID_SIZE.getMessage());
+    }
+
+    @Test
+    void 사이즈_파라미터가_음수이면_예외_응답을_반환한다() {
+        // given
+        request.setParameter(SIZE_PARAMETER, "-1");
+
+        // when & then
+        assertThatCode(() -> customPageableHandlerMethodArgumentResolver
+                .resolveArgument(parameter, null, webRequest, null))
+                .isInstanceOf(CustomException.class)
+                .hasMessage(INVALID_SIZE.getMessage());
+    }
+
+    private static class TestController {
+
+        public void pageableMethod(Pageable pageable) {
+        }
+    }
+}