diff --git a/src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java b/src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java index e73d24bd2..7f6804ec4 100644 --- a/src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java +++ b/src/main/java/org/springframework/data/web/PageableHandlerMethodArgumentResolver.java @@ -51,8 +51,8 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum static { LEGACY = new PageableHandlerMethodArgumentResolver(); - LEGACY.pageProperty = "page.page"; - LEGACY.sizeProperty = "page.size"; + LEGACY.pageParameterName = "page.page"; + LEGACY.sizeParameterName = "page.size"; LEGACY.fallbackPageable = new PageRequest(1, 10); LEGACY.oneIndexedParameters = true; LEGACY.sortResolver.setLegacyMode(true); @@ -63,15 +63,15 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum private static final String DEFAULT_PAGE_PROPERTY = "page"; private static final String DEFAULT_SIZE_PROPERTY = "size"; private static final String DEFAULT_PREFIX = ""; - private static final String DEFAULT_QUALIFIER_SEPARATOR = "_"; + private static final String DEFAULT_QUALIFIER_DELIMITER = "_"; private static final int DEFAULT_MAX_PAGE_SIZE = 2000; private Pageable fallbackPageable = DEFAULT_PAGE_REQUEST; private SortHandlerMethodArgumentResolver sortResolver = new SortHandlerMethodArgumentResolver(); - private String pageProperty = DEFAULT_PAGE_PROPERTY; - private String sizeProperty = DEFAULT_SIZE_PROPERTY; + private String pageParameterName = DEFAULT_PAGE_PROPERTY; + private String sizeParameterName = DEFAULT_SIZE_PROPERTY; private String prefix = DEFAULT_PREFIX; - private String qualifierSeparator = DEFAULT_QUALIFIER_SEPARATOR; + private String qualifierDelimiter = DEFAULT_QUALIFIER_DELIMITER; private int maxPageSize = DEFAULT_MAX_PAGE_SIZE; private boolean oneIndexedParameters = false; @@ -102,23 +102,23 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum /** * Configures the parameter name to be used to find the page number in the request. Defaults to {@code page}. * - * @param pageProperty the parameter name to be used, must not be {@literal null} or empty. + * @param pageParameterName the parameter name to be used, must not be {@literal null} or empty. */ - public void setPageProperty(String pageProperty) { + public void setPageParameterName(String pageParameterName) { - Assert.hasText(pageProperty, "Page parameter name must not be null or empty!"); - this.pageProperty = pageProperty; + Assert.hasText(pageParameterName, "Page parameter name must not be null or empty!"); + this.pageParameterName = pageParameterName; } /** * Configures the parameter name to be used to find the page size in the request. Defaults to {@code size}. * - * @param sizeProperty the parameter name to be used, must not be {@literal null} or empty. + * @param sizeParameterName the parameter name to be used, must not be {@literal null} or empty. */ - public void setSizeProperty(String sizeProperty) { + public void setSizeParameterName(String sizeParameterName) { - Assert.hasText(sizeProperty, "Size parameter name must not be null or empty!"); - this.sizeProperty = sizeProperty; + Assert.hasText(sizeParameterName, "Size parameter name must not be null or empty!"); + this.sizeParameterName = sizeParameterName; } /** @@ -132,13 +132,13 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum } /** - * The separator to be used between the qualifier and the actual page number and size properties. Defaults to + * The delimiter to be used between the qualifier and the actual page number and size properties. Defaults to * {@code _}. So a qualifier of {@code foo} will result in a page number parameter of {@code foo_page}. * - * @param qualifierSeparator the qualifierSeparator to be used or {@literal null} to reset to the default. + * @param qualifierDelimiter the delimter to be used or {@literal null} to reset to the default. */ - public void setQualifierSeparator(String qualifierSeparator) { - this.qualifierSeparator = qualifierSeparator == null ? DEFAULT_QUALIFIER_SEPARATOR : qualifierSeparator; + public void setQualifierDelimiter(String qualifierDelimiter) { + this.qualifierDelimiter = qualifierDelimiter == null ? DEFAULT_QUALIFIER_DELIMITER : qualifierDelimiter; } /** @@ -183,8 +183,8 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum Pageable pageable = (Pageable) value; - String pagePropertyName = getParameterNameToUse(pageProperty, parameter); - String sizePropertyName = getParameterNameToUse(sizeProperty, parameter); + String pagePropertyName = getParameterNameToUse(pageParameterName, parameter); + String sizePropertyName = getParameterNameToUse(sizeParameterName, parameter); int pageNumber = pageable.getPageNumber(); @@ -206,8 +206,8 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum Pageable defaultOrFallback = getDefaultFromAnnotationOrFallback(methodParameter); - String pageString = webRequest.getParameter(getParameterNameToUse(pageProperty, methodParameter)); - String pageSizeString = webRequest.getParameter(getParameterNameToUse(sizeProperty, methodParameter)); + String pageString = webRequest.getParameter(getParameterNameToUse(pageParameterName, methodParameter)); + String pageSizeString = webRequest.getParameter(getParameterNameToUse(sizeParameterName, methodParameter)); int page = StringUtils.hasText(pageString) ? Integer.parseInt(pageString) - (oneIndexedParameters ? 1 : 0) : defaultOrFallback.getPageNumber(); @@ -233,7 +233,7 @@ public class PageableHandlerMethodArgumentResolver implements HandlerMethodArgum if (parameter != null && parameter.hasParameterAnnotation(Qualifier.class)) { builder.append(parameter.getParameterAnnotation(Qualifier.class).value()); - builder.append(qualifierSeparator); + builder.append(qualifierDelimiter); } return builder.append(source).toString(); diff --git a/src/test/java/org/springframework/data/web/PageableDefaultUnitTests.java b/src/test/java/org/springframework/data/web/PageableDefaultUnitTests.java index 31e83b325..19519e851 100644 --- a/src/test/java/org/springframework/data/web/PageableDefaultUnitTests.java +++ b/src/test/java/org/springframework/data/web/PageableDefaultUnitTests.java @@ -19,6 +19,8 @@ import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.*; import static org.springframework.data.web.SortDefaultUnitTests.*; +import javax.servlet.http.HttpServletRequest; + import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; @@ -28,6 +30,7 @@ import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; import org.springframework.test.util.ReflectionTestUtils; import org.springframework.web.context.request.NativeWebRequest; +import org.springframework.web.context.request.ServletWebRequest; import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.util.UriComponentsBuilder; @@ -128,6 +131,11 @@ public abstract class PageableDefaultUnitTests { assertSupportedAndResult(parameter, pageable, TestUtils.getWebRequest()); } + protected void assertSupportedAndResult(MethodParameter parameter, Pageable pageable, HttpServletRequest request) + throws Exception { + assertSupportedAndResult(parameter, pageable, new ServletWebRequest(request)); + } + protected void assertSupportedAndResult(MethodParameter parameter, Pageable pageable, NativeWebRequest request) throws Exception { diff --git a/src/test/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverUnitTests.java b/src/test/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverUnitTests.java index ad58dbbc7..5f124d2b5 100644 --- a/src/test/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverUnitTests.java +++ b/src/test/java/org/springframework/data/web/PageableHandlerMethodArgumentResolverUnitTests.java @@ -30,7 +30,6 @@ import org.springframework.data.web.SortDefault.SortDefaults; import org.springframework.hateoas.mvc.UriComponentsContributor; import org.springframework.mock.web.MockHttpServletRequest; import org.springframework.util.MultiValueMap; -import org.springframework.web.context.request.ServletWebRequest; import org.springframework.web.util.UriComponentsBuilder; /** @@ -67,7 +66,7 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa MethodParameter parameter = new MethodParameter(Sample.class.getMethod("supportedMethod", Pageable.class), 0); - assertSupportedAndResult(parameter, new PageRequest(0, 100), new ServletWebRequest(request)); + assertSupportedAndResult(parameter, new PageRequest(0, 100), request); } /** @@ -92,6 +91,38 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa assertThat(size.get(0), is("20")); } + @Test(expected = IllegalArgumentException.class) + public void rejectsEmptyPageParameterName() { + new PageableHandlerMethodArgumentResolver().setPageParameterName(""); + } + + @Test(expected = IllegalArgumentException.class) + public void rejectsNullPageParameterName() { + new PageableHandlerMethodArgumentResolver().setPageParameterName(null); + } + + @Test(expected = IllegalArgumentException.class) + public void rejectsEmptySizeParameterName() { + new PageableHandlerMethodArgumentResolver().setSizeParameterName(""); + } + + @Test(expected = IllegalArgumentException.class) + public void rejectsNullSizeParameterName() { + new PageableHandlerMethodArgumentResolver().setSizeParameterName(null); + } + + @Test + public void qualifierIsUsedInParameterLookup() throws Exception { + + MethodParameter parameter = new MethodParameter(Sample.class.getMethod("validQualifier", Pageable.class), 0); + + MockHttpServletRequest request = new MockHttpServletRequest(); + request.addParameter("foo_page", "2"); + request.addParameter("foo_size", "10"); + + assertSupportedAndResult(parameter, new PageRequest(2, 10), request); + } + @Override protected PageableHandlerMethodArgumentResolver getResolver() { PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver(); @@ -126,6 +157,8 @@ public class PageableHandlerMethodArgumentResolverUnitTests extends PageableDefa void invalidQualifiers(@Qualifier("foo") Pageable first, @Qualifier("foo") Pageable second); + void validQualifier(@Qualifier("foo") Pageable pageable); + void noQualifiers(Pageable first, Pageable second); } }