Reintroduce Specification.where(Specification)

Reintroduce the  overload to improve the migration path for users upgrading to Spring Data JPA 4.0 and to restore the intuitive fluent API but this time, the method does not accept null values.

Closes #3992
Original pull request: #3998

Signed-off-by: 희은 <[email protected]>

Author: nam0oo

spring-data-jpa/src/main/java/org/springframework/data/jpa/domain/Specification.java

@@ -48,6 +48,7 @@
  * @author Jens Schauder
  * @author Daniel Shuy
  * @author Sergey Rukin
+ * @author Heeeun Cho
  */
 @FunctionalInterface
 public interface Specification<T> extends Serializable {
@@ -78,6 +79,21 @@ static <T> Specification<T> where(PredicateSpecification<T> spec) {
 		return (root, update, criteriaBuilder) -> spec.toPredicate(root, criteriaBuilder);
 	}
 
+	/**
+	 * Creates a {@link Specification} from the given {@link Specification}. This is a factory method for fluent composition.
+	 *
+	 * @param <T> the type of the {@link Root} the resulting {@literal Specification} operates on.
+	 * @param spec must not be {@literal null}.
+	 * @return the given specification.
+	 * @since 4.1
+	 */
+	static <T> Specification<T> where(Specification<T> spec) {
+
+		Assert.notNull(spec, "Specification must not be null");
+
+		return spec;
+	}
+
 	/**
 	 * ANDs the given {@link Specification} to the current one.
 	 *

spring-data-jpa/src/test/java/org/springframework/data/jpa/domain/SpecificationUnitTests.java

@@ -42,6 +42,7 @@
  * @author Jens Schauder
  * @author Mark Paluch
  * @author Daniel Shuy
+ * @author Heeeun Cho
  */
 @SuppressWarnings({ "unchecked", "deprecation" })
 @ExtendWith(MockitoExtension.class)
@@ -137,6 +138,36 @@ void notWithNullPredicate() {
 		verify(builder).disjunction();
 	}
 
+	@Test // GH-3992
+	void whereWithSpecificationReturnsSameSpecification() {
+
+		Specification<Object> originalSpec = (r, q, cb) -> predicate;
+		Specification<Object> wrappedSpec = Specification.where(originalSpec);
+
+		assertThat(wrappedSpec).isSameAs(originalSpec);
+	}
+
+	@Test // GH-3992
+	void whereWithSpecificationSupportsFluentComposition() {
+
+		Specification<Object> firstSpec = (r, q, cb) -> predicate;
+		Specification<Object> secondSpec = (r, q, cb) -> predicate;
+
+		Specification<Object> composedSpec = Specification.where(firstSpec).and(secondSpec);
+
+		assertThat(composedSpec).isNotNull();
+		composedSpec.toPredicate(root, query, builder);
+		verify(builder).and(predicate, predicate);
+	}
+
+	@Test // GH-3992
+	void whereWithNullSpecificationThrowsException() {
+
+		assertThatThrownBy(() -> Specification.where((Specification<Object>) null))
+				.isInstanceOf(IllegalArgumentException.class)
+				.hasMessage("Specification must not be null");
+	}
+
 	static class SerializableSpecification implements Serializable, Specification<Object> {
 
 		@Override