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.

Closes #3992

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