Polishing.

Reformat code, limit scope to nullHandling in SortDefault.

See #3152
Original pull request: #3153

Author: mp911de

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

@@ -44,40 +44,31 @@
 
 	/**
 	 * Alias for {@link #sort()} to make a declaration configuring fields only more concise.
-	 *
-	 * @return
 	 */
 	@AliasFor("sort")
 	String[] value() default {};
 
 	/**
-	 * The properties to sort by default. If unset, no sorting will be applied at all.
-	 *
-	 * @return
+	 * The properties to sort by default. If not set, no sorting will be applied at all.
 	 */
 	@AliasFor("value")
 	String[] sort() default {};
 
 	/**
 	 * The direction to sort by. Defaults to {@link Direction#ASC}.
-	 *
-	 * @return
 	 */
 	Direction direction() default Direction.ASC;
 
 	/**
 	 * Specifies whether to apply case-sensitive sorting. Defaults to {@literal true}.
-	 *
-	 * @return
 	 * @since 2.3
 	 */
 	boolean caseSensitive() default true;
 
 	/**
 	 * Specifies which null handling to apply. Defaults to {@link NullHandling#NATIVE}.
 	 *
-	 * @return
-	 * @since 3.4
+	 * @since 4.0.5
 	 */
 	NullHandling nullHandling() default NullHandling.NATIVE;
 
@@ -94,9 +85,9 @@
 
 		/**
 		 * The individual {@link SortDefault} declarations to be sorted by.
-		 *
-		 * @return
 		 */
 		SortDefault[] value();
+
 	}
+
 }

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

@@ -54,9 +54,6 @@ public abstract class SortHandlerMethodArgumentResolverSupport {
 	private static final String DEFAULT_QUALIFIER_DELIMITER = "_";
 	private static final Sort DEFAULT_SORT = Sort.unsorted();
 
-	private static final String SORT_DEFAULTS_NAME = SortDefaults.class.getSimpleName();
-	private static final String SORT_DEFAULT_NAME = SortDefault.class.getSimpleName();
-
 	private Sort fallbackSort = DEFAULT_SORT;
 	private String sortParameter = DEFAULT_PARAMETER;
 	private String propertyDelimiter = DEFAULT_PROPERTY_DELIMITER;
@@ -165,17 +162,21 @@ private Sort appendOrCreateSortTo(MergedAnnotation<SortDefault> sortDefault, Sor
 		}
 
 		List<Order> orders = new ArrayList<>(fields.length);
+		Direction direction = sortDefault.getEnum("direction", Direction.class);
+		NullHandling nullHandling = sortDefault.getEnum("nullHandling", NullHandling.class);
+		boolean caseSensitive = sortDefault.getBoolean("caseSensitive");
+
 		for (String field : fields) {
 
-			Order order = new Order(sortDefault.getEnum("direction", Direction.class), field);
+			Order order = new Order(direction, field);
 
-			order = switch (sortDefault.getEnum("nullHandling", NullHandling.class)) {
+			order = switch (nullHandling) {
 				case NATIVE -> order.nullsNative();
 				case NULLS_FIRST -> order.nullsFirst();
 				case NULLS_LAST -> order.nullsLast();
 			};
 
-			orders.add(sortDefault.getBoolean("caseSensitive") ? order : order.ignoreCase());
+			orders.add(caseSensitive ? order : order.ignoreCase());
 		}
 
 		return sortOrNull.and(Sort.by(orders));
@@ -223,7 +224,6 @@ Sort parseParameterIntoSort(List<String> source, String delimiter) {
 			}
 
 			SortOrderParser.parse(part, delimiter) //
-					.parseNullHandling() //
 					.parseIgnoreCase() //
 					.parseDirection() //
 					.forEachOrder(allOrders::add);
@@ -370,28 +370,23 @@ List<String> dumpExpressionIfPresentInto(List<String> expressions) {
 	static class SortOrderParser {
 
 		private static final String IGNORECASE = "ignorecase";
-		private static final String NULLSNATIVE = "nullsnative";
-		private static final String NULLSFIRST = "nullsfirst";
-		private static final String NULLSLAST = "nullslast";
 
 		private final String[] elements;
 		private final int lastIndex;
 		private final Optional<Direction> direction;
 		private final Optional<Boolean> ignoreCase;
-		private final Optional<NullHandling> nullHandling;
 
 		private SortOrderParser(String[] elements) {
-			this(elements, elements.length, Optional.empty(), Optional.empty(), Optional.empty());
+			this(elements, elements.length, Optional.empty(), Optional.empty());
 		}
 
 		private SortOrderParser(String[] elements, int lastIndex, Optional<Direction> direction,
-				Optional<Boolean> ignoreCase, Optional<NullHandling> nullHandling) {
+				Optional<Boolean> ignoreCase) {
 
 			this.elements = elements;
 			this.lastIndex = Math.max(0, lastIndex);
 			this.direction = direction;
 			this.ignoreCase = ignoreCase;
-			this.nullHandling = nullHandling;
 		}
 
 		/**
@@ -410,21 +405,6 @@ public static SortOrderParser parse(String part, String delimiter) {
 			return new SortOrderParser(elements);
 		}
 
-		/**
-		 * Parse the {@link NullHandling} portion of the sort specification.
-		 *
-		 * @return a new parsing state object.
-		 */
-		public SortOrderParser parseNullHandling() {
-
-			Optional<NullHandling> nullHandling = lastIndex > 0 ?
-					fromOptionalNullHandlingString(elements[lastIndex - 1]) :
-					Optional.empty();
-
-			return new SortOrderParser(elements, lastIndex - (nullHandling.isPresent() ? 1 : 0), direction, ignoreCase,
-					nullHandling);
-		}
-
 		/**
 		 * Parse the {@code ignoreCase} portion of the sort specification.
 		 *
@@ -436,8 +416,7 @@ public SortOrderParser parseIgnoreCase() {
 					fromOptionalIgnoreCaseString(elements[lastIndex - 1]) :
 					Optional.empty();
 
-			return new SortOrderParser(elements, lastIndex - (ignoreCase.isPresent() ? 1 : 0), direction, ignoreCase,
-					nullHandling);
+			return new SortOrderParser(elements, lastIndex - (ignoreCase.isPresent() ? 1 : 0), direction, ignoreCase);
 		}
 
 		/**
@@ -450,8 +429,7 @@ public SortOrderParser parseDirection() {
 			Optional<Direction> direction = lastIndex > 0 ? Direction.fromOptionalString(elements[lastIndex - 1])
 					: Optional.empty();
 
-			return new SortOrderParser(elements, lastIndex - (direction.isPresent() ? 1 : 0), direction, ignoreCase,
-					nullHandling);
+			return new SortOrderParser(elements, lastIndex - (direction.isPresent() ? 1 : 0), direction, ignoreCase);
 		}
 
 		/**
@@ -466,23 +444,6 @@ public void forEachOrder(Consumer<? super Order> callback) {
 			}
 		}
 
-		private Optional<NullHandling> fromOptionalNullHandlingString(String value) {
-
-			if (NULLSNATIVE.equalsIgnoreCase(value)) {
-				return Optional.of(NullHandling.NATIVE);
-			}
-
-			if (NULLSFIRST.equalsIgnoreCase(value)) {
-				return Optional.of(NullHandling.NULLS_FIRST);
-			}
-
-			if (NULLSLAST.equalsIgnoreCase(value)) {
-				return Optional.of(NullHandling.NULLS_LAST);
-			}
-
-			return Optional.empty();
-		}
-
 		private Optional<Boolean> fromOptionalIgnoreCaseString(String value) {
 			return IGNORECASE.equalsIgnoreCase(value) ? Optional.of(true) : Optional.empty();
 		}
@@ -495,14 +456,6 @@ private Optional<Order> toOrder(String property) {
 
 			Order order = direction.map(it -> new Order(it, property)).orElseGet(() -> Order.by(property));
 
-			if (nullHandling.isPresent()) {
-				order = switch (nullHandling.get()) {
-					case NATIVE -> order.nullsNative();
-					case NULLS_FIRST -> order.nullsFirst();
-					case NULLS_LAST -> order.nullsLast();
-				};
-			}
-
 			if (ignoreCase.isPresent()) {
 				return Optional.of(order.ignoreCase());
 			}