Skip to content

Commit 53cfbfb

Browse files
pheykenmp911de
pheyken
authored and
mp911de
committed
Add nullHandling to @SortDefault.
Closes #3152 Original pull request: #3153
1 parent 06a0d31 commit 53cfbfb

3 files changed

Lines changed: 137 additions & 7 deletions

File tree

‎src/main/java/org/springframework/data/web/SortDefault.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
import org.springframework.core.annotation.AliasFor;
2626
import org.springframework.data.domain.Sort;
2727
import org.springframework.data.domain.Sort.Direction;
28+
import org.springframework.data.domain.Sort.NullHandling;
2829

2930
/**
3031
* Annotation to define the default {@link Sort} options to be used when injecting a {@link Sort} instance into a
@@ -33,6 +34,7 @@
3334
* @since 1.6
3435
* @author Oliver Gierke
3536
* @author Mark Palich
37+
* @author Petar Heyken
3638
*/
3739
@Documented
3840
@Retention(RetentionPolicy.RUNTIME)
@@ -71,6 +73,14 @@
7173
*/
7274
boolean caseSensitive() default true;
7375

76+
/**
77+
* Specifies which null handling to apply. Defaults to {@link NullHandling#NATIVE}.
78+
*
79+
* @return
80+
* @since 3.4
81+
*/
82+
NullHandling nullHandling() default NullHandling.NATIVE;
83+
7484
/**
7585
* Wrapper annotation to allow declaring multiple {@link SortDefault} annotations on a method parameter.
7686
*

‎src/main/java/org/springframework/data/web/SortHandlerMethodArgumentResolverSupport.java‎

Lines changed: 67 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@
2929
import org.springframework.core.annotation.RepeatableContainers;
3030
import org.springframework.data.domain.Sort;
3131
import org.springframework.data.domain.Sort.Direction;
32+
import org.springframework.data.domain.Sort.NullHandling;
3233
import org.springframework.data.domain.Sort.Order;
3334
import org.springframework.data.web.SortDefault.SortDefaults;
3435
import org.springframework.util.Assert;
@@ -41,6 +42,7 @@
4142
* @author Mark Paluch
4243
* @author Vedran Pavic
4344
* @author Johannes Englmeier
45+
* @author Petar Heyken
4446
* @see SortHandlerMethodArgumentResolver
4547
* @see ReactiveSortHandlerMethodArgumentResolver
4648
* @since 2.2
@@ -165,7 +167,14 @@ private Sort appendOrCreateSortTo(MergedAnnotation<SortDefault> sortDefault, Sor
165167
List<Order> orders = new ArrayList<>(fields.length);
166168
for (String field : fields) {
167169

168-
Order order = new Order(sortDefault.getEnum("direction", Sort.Direction.class), field);
170+
Order order = new Order(sortDefault.getEnum("direction", Direction.class), field);
171+
172+
order = switch (sortDefault.getEnum("nullHandling", NullHandling.class)) {
173+
case NATIVE -> order.nullsNative();
174+
case NULLS_FIRST -> order.nullsFirst();
175+
case NULLS_LAST -> order.nullsLast();
176+
};
177+
169178
orders.add(sortDefault.getBoolean("caseSensitive") ? order : order.ignoreCase());
170179
}
171180

@@ -214,6 +223,7 @@ Sort parseParameterIntoSort(List<String> source, String delimiter) {
214223
}
215224

216225
SortOrderParser.parse(part, delimiter) //
226+
.parseNullHandling() //
217227
.parseIgnoreCase() //
218228
.parseDirection() //
219229
.forEachOrder(allOrders::add);
@@ -360,22 +370,28 @@ List<String> dumpExpressionIfPresentInto(List<String> expressions) {
360370
static class SortOrderParser {
361371

362372
private static final String IGNORECASE = "ignorecase";
373+
private static final String NULLSNATIVE = "nullsnative";
374+
private static final String NULLSFIRST = "nullsfirst";
375+
private static final String NULLSLAST = "nullslast";
363376

364377
private final String[] elements;
365378
private final int lastIndex;
366379
private final Optional<Direction> direction;
367380
private final Optional<Boolean> ignoreCase;
381+
private final Optional<NullHandling> nullHandling;
368382

369383
private SortOrderParser(String[] elements) {
370-
this(elements, elements.length, Optional.empty(), Optional.empty());
384+
this(elements, elements.length, Optional.empty(), Optional.empty(), Optional.empty());
371385
}
372386

373387
private SortOrderParser(String[] elements, int lastIndex, Optional<Direction> direction,
374-
Optional<Boolean> ignoreCase) {
388+
Optional<Boolean> ignoreCase, Optional<NullHandling> nullHandling) {
389+
375390
this.elements = elements;
376391
this.lastIndex = Math.max(0, lastIndex);
377392
this.direction = direction;
378393
this.ignoreCase = ignoreCase;
394+
this.nullHandling = nullHandling;
379395
}
380396

381397
/**
@@ -394,16 +410,34 @@ public static SortOrderParser parse(String part, String delimiter) {
394410
return new SortOrderParser(elements);
395411
}
396412

413+
/**
414+
* Parse the {@link NullHandling} portion of the sort specification.
415+
*
416+
* @return a new parsing state object.
417+
*/
418+
public SortOrderParser parseNullHandling() {
419+
420+
Optional<NullHandling> nullHandling = lastIndex > 0 ?
421+
fromOptionalNullHandlingString(elements[lastIndex - 1]) :
422+
Optional.empty();
423+
424+
return new SortOrderParser(elements, lastIndex - (nullHandling.isPresent() ? 1 : 0), direction, ignoreCase,
425+
nullHandling);
426+
}
427+
397428
/**
398429
* Parse the {@code ignoreCase} portion of the sort specification.
399430
*
400431
* @return a new parsing state object.
401432
*/
402433
public SortOrderParser parseIgnoreCase() {
403434

404-
Optional<Boolean> ignoreCase = lastIndex > 0 ? fromOptionalString(elements[lastIndex - 1]) : Optional.empty();
435+
Optional<Boolean> ignoreCase = lastIndex > 0 ?
436+
fromOptionalIgnoreCaseString(elements[lastIndex - 1]) :
437+
Optional.empty();
405438

406-
return new SortOrderParser(elements, lastIndex - (ignoreCase.isPresent() ? 1 : 0), direction, ignoreCase);
439+
return new SortOrderParser(elements, lastIndex - (ignoreCase.isPresent() ? 1 : 0), direction, ignoreCase,
440+
nullHandling);
407441
}
408442

409443
/**
@@ -416,7 +450,8 @@ public SortOrderParser parseDirection() {
416450
Optional<Direction> direction = lastIndex > 0 ? Direction.fromOptionalString(elements[lastIndex - 1])
417451
: Optional.empty();
418452

419-
return new SortOrderParser(elements, lastIndex - (direction.isPresent() ? 1 : 0), direction, ignoreCase);
453+
return new SortOrderParser(elements, lastIndex - (direction.isPresent() ? 1 : 0), direction, ignoreCase,
454+
nullHandling);
420455
}
421456

422457
/**
@@ -431,7 +466,24 @@ public void forEachOrder(Consumer<? super Order> callback) {
431466
}
432467
}
433468

434-
private Optional<Boolean> fromOptionalString(String value) {
469+
private Optional<NullHandling> fromOptionalNullHandlingString(String value) {
470+
471+
if (NULLSNATIVE.equalsIgnoreCase(value)) {
472+
return Optional.of(NullHandling.NATIVE);
473+
}
474+
475+
if (NULLSFIRST.equalsIgnoreCase(value)) {
476+
return Optional.of(NullHandling.NULLS_FIRST);
477+
}
478+
479+
if (NULLSLAST.equalsIgnoreCase(value)) {
480+
return Optional.of(NullHandling.NULLS_LAST);
481+
}
482+
483+
return Optional.empty();
484+
}
485+
486+
private Optional<Boolean> fromOptionalIgnoreCaseString(String value) {
435487
return IGNORECASE.equalsIgnoreCase(value) ? Optional.of(true) : Optional.empty();
436488
}
437489

@@ -443,6 +495,14 @@ private Optional<Order> toOrder(String property) {
443495

444496
Order order = direction.map(it -> new Order(it, property)).orElseGet(() -> Order.by(property));
445497

498+
if (nullHandling.isPresent()) {
499+
order = switch (nullHandling.get()) {
500+
case NATIVE -> order.nullsNative();
501+
case NULLS_FIRST -> order.nullsFirst();
502+
case NULLS_LAST -> order.nullsLast();
503+
};
504+
}
505+
446506
if (ignoreCase.isPresent()) {
447507
return Optional.of(order.ignoreCase());
448508
}

‎src/test/java/org/springframework/data/web/SortHandlerMethodArgumentResolverUnitTests.java‎

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@
4848
* @author Nick Williams
4949
* @author Mark Paluch
5050
* @author Vedran Pavic
51+
* @author Petar Heyken
5152
*/
5253
class SortHandlerMethodArgumentResolverUnitTests extends SortDefaultUnitTests {
5354

@@ -211,6 +212,16 @@ void returnsDefaultCaseInsensitive() throws Exception {
211212
.isEqualTo(Sort.by(new Order(DESC, "firstname").ignoreCase(), new Order(DESC, "lastname").ignoreCase()));
212213
}
213214

215+
@Test // GH-3152
216+
void returnsDefaultNullHandling() throws Exception {
217+
218+
final var request = new MockHttpServletRequest();
219+
request.addParameter("sort", "");
220+
221+
assertThat(resolveSort(request, getParameterOfMethod("simpleDefaultWithDirectionAndNullHandling"))).isEqualTo(
222+
Sort.by(new Order(DESC, "firstname").nullsLast(), new Order(DESC, "lastname").nullsLast()));
223+
}
224+
214225
@Test // DATACMNS-379
215226
void parsesCommaParameterForSort() throws Exception {
216227

@@ -273,6 +284,52 @@ void readsEncodedSort() {
273284
assertSupportedAndResolvedTo(new ServletWebRequest(request), parameter, Sort.by("foo").descending());
274285
}
275286

287+
@Test // GH-3152
288+
void sortParamHandlesMultiplePropertiesWithSortOrderAndIgnoreCaseAndNullsLast() throws Exception {
289+
290+
final var request = new MockHttpServletRequest();
291+
request.addParameter("sort", "property1,property2,DESC,IgnoreCase,NullsLast");
292+
293+
assertThat(resolveSort(request, PARAMETER)).isEqualTo(Sort.by(new Order(DESC, "property1").ignoreCase().nullsLast(),
294+
new Order(DESC, "property2").ignoreCase().nullsLast()));
295+
}
296+
297+
@Test // GH-3152
298+
void sortParamHandlesSinglePropertyWithIgnoreCaseAndNullsLast() throws Exception {
299+
300+
final var request = new MockHttpServletRequest();
301+
request.addParameter("sort", "property,IgnoreCase,NullsLast");
302+
303+
assertThat(resolveSort(request, PARAMETER)).isEqualTo(Sort.by(new Order(ASC, "property").ignoreCase().nullsLast()));
304+
}
305+
306+
@Test // GH-3152
307+
void sortParamHandlesSinglePropertyWithNullsFirst() throws Exception {
308+
309+
final var request = new MockHttpServletRequest();
310+
request.addParameter("sort", "property,nullsfirst");
311+
312+
assertThat(resolveSort(request, PARAMETER)).isEqualTo(Sort.by(new Order(ASC, "property").nullsFirst()));
313+
}
314+
315+
@Test // GH-3152
316+
void sortParamHandlesSinglePropertyWithSortOrderAndWithNullsFirst() throws Exception {
317+
318+
final var request = new MockHttpServletRequest();
319+
request.addParameter("sort", "property,DESC,nullsfirst");
320+
321+
assertThat(resolveSort(request, PARAMETER)).isEqualTo(Sort.by(new Order(DESC, "property").nullsFirst()));
322+
}
323+
324+
@Test // GH-3152
325+
void sortParamHandlesSinglePropertyWithSortOrderAndWithNullsNative() throws Exception {
326+
327+
final var request = new MockHttpServletRequest();
328+
request.addParameter("sort", "property,DESC,nullsnative");
329+
330+
assertThat(resolveSort(request, PARAMETER)).isEqualTo(Sort.by(new Order(DESC, "property").nullsNative()));
331+
}
332+
276333
private static Sort resolveSort(HttpServletRequest request, MethodParameter parameter) throws Exception {
277334

278335
var resolver = new SortHandlerMethodArgumentResolver();
@@ -335,6 +392,9 @@ void simpleDefaultWithDirection(
335392
void simpleDefaultWithDirectionCaseInsensitive(
336393
@SortDefault(sort = { "firstname", "lastname" }, direction = Direction.DESC, caseSensitive = false) Sort sort);
337394

395+
void simpleDefaultWithDirectionAndNullHandling(
396+
@SortDefault(sort = { "firstname", "lastname" }, direction = Direction.DESC, nullHandling = Sort.NullHandling.NULLS_LAST) Sort sort);
397+
338398
void containeredDefault(@SortDefaults(@SortDefault({ "foo", "bar" })) Sort sort);
339399

340400
void repeatable(@SortDefault({ "one", "two" }) @SortDefault({ "three" }) Sort sort);

0 commit comments

Comments
 (0)