Stop supporting params not annotated with @ProjectedPayload.

This commit drops support for projections if a parameter (or the parameter type)
is not explicitly annotated with `@ProjectedPayload`. A warning is still logged
in these cases to help user understand why the parameter is not being projected.

Also, simplify tests.

Closes #3301
Original pull request: #3453
Related ticket: #3298

Author: onobc

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

@@ -115,7 +115,7 @@ public boolean supportsParameter(MethodParameter parameter) {
 		// Parameter annotated with @ModelAttribute
 		if (parameter.hasParameterAnnotation(ModelAttribute.class)) {
 			this.deprecationLogger.logDeprecationForParameter(parameter);
-			return true;
+			return false;
 		}
 
 		// Exclude any other parameters annotated with Spring annotation
@@ -131,7 +131,7 @@ public boolean supportsParameter(MethodParameter parameter) {
 		String packageName = ClassUtils.getPackageName(type);
 		if (IGNORED_PACKAGES.stream().noneMatch(packageName::startsWith)) {
 			this.deprecationLogger.logDeprecationForParameter(parameter);
-			return true;
+			return false;
 		}
 
 		return false;
@@ -157,7 +157,7 @@ protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest requ
 	 */
 	static class ProjectedPayloadDeprecationLogger {
 
-		private static final String MESSAGE = "Parameter %sat index %s in [%s] is not annotated with @ProjectedPayload. Support for parameters not annotated with @ProjectedPayload (at the parameter or type level) will be dropped in a future version.";
+		private static final String MESSAGE = "Parameter %sat index %s in [%s] is not annotated with @ProjectedPayload. Make sure to annotate it with @ProjectedPayload (at the parameter or type level) to use it for projections.";
 
 		private final Set<MethodParameter> loggedParameters = Collections.synchronizedSet(new HashSet<>());
 

src/test/java/example/ProjectedPayloadMarkedSampleInterface.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2026-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Chris Bono
+ * @see org.springframework.data.web.ProxyingHandlerMethodArgumentResolverUnitTests
+ */
+package example;
+
+import org.springframework.data.web.ProjectedPayload;
+
+@ProjectedPayload
+public interface ProjectedPayloadMarkedSampleInterface {}

src/test/java/org/springframework/data/web/ProxyingHandlerMethodArgumentResolverUnitTests.java

@@ -18,6 +18,7 @@
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import example.ProjectedPayloadMarkedSampleInterface;
 import example.SampleInterface;
 
 import java.lang.reflect.Method;
@@ -52,25 +53,33 @@ class ProxyingHandlerMethodArgumentResolverUnitTests {
 			() -> new DefaultConversionService(), true);
 
 	@Test // DATACMNS-776
-	void supportAnnotatedInterface() {
+	void supportsAnnotatedInterfaceFromSpringNamespace() {
 
-		var parameter = getParameter("with", AnnotatedInterface.class);
+		var parameter = getParameter("withSpringAnnotatedInterface");
 
 		assertThat(resolver.supportsParameter(parameter)).isTrue();
 	}
 
 	@Test // DATACMNS-776
-	void supportsUnannotatedInterfaceFromUserPackage() {
+	void doesNotSupportUnannotatedInterfaceFromSpringNamespace() {
+
+		var parameter = getParameter("withSpringUnannotatedInterface");
+
+		assertThat(resolver.supportsParameter(parameter)).isFalse();
+	}
 
-		var parameter = getParameter("with", SampleInterface.class);
+	@Test // GH-3301
+	void supportsAnnotatedInterfaceFromUserPackage() {
+
+		var parameter = getParameter("withUserAnnotatedInterface");
 
 		assertThat(resolver.supportsParameter(parameter)).isTrue();
 	}
 
-	@Test // DATACMNS-776
-	void doesNotSupportUnannotatedInterfaceFromSpringNamespace() {
+	@Test // GH-3301
+	void doesNotSupportUnannotatedInterfaceFromUserPackage() {
 
-		var parameter = getParameter("with", UnannotatedInterface.class);
+		var parameter = getParameter("withUserUnannotatedInterface");
 
 		assertThat(resolver.supportsParameter(parameter)).isFalse();
 	}
@@ -91,12 +100,12 @@ void doesNotSupportForeignSpringAnnotations() {
 		assertThat(resolver.supportsParameter(parameter)).isFalse();
 	}
 
-	@Test // GH-2937
-	void doesSupportAtModelAttribute() {
+	@Test // GH-3301
+	void doesNotSupportAtModelAttribute() {
 
 		var parameter = getParameter("withModelAttribute", SampleInterface.class);
 
-		assertThat(resolver.supportsParameter(parameter)).isTrue();
+		assertThat(resolver.supportsParameter(parameter)).isFalse();
 	}
 
 	@Test // GH-3258
@@ -123,26 +132,27 @@ void doesNotSupportAtProjectedPayloadForMultipartParam() {
 		assertThat(resolver.supportsParameter(parameter)).isFalse();
 	}
 
-	@Test // GH-3300
+	@ParameterizedTest // GH-3300
+	@ValueSource(strings = { "withModelAttribute", "withUserUnannotatedInterface" })
 	@SuppressWarnings("unchecked")
-	void deprecationLoggerOnlyLogsOncePerParameter() {
+	void deprecationLoggerOnlyLogsOncePerParameter(String methodName) {
 
-		var parameter = getParameter("withModelAttribute", SampleInterface.class);
+		var parameter = getParameter(methodName);
 
 		// Spy on the actual logger
 		var actualLoggerSpy = spy(new LogAccessor(ProxyingHandlerMethodArgumentResolver.class));
 		ReflectionTestUtils.setField(ProxyingHandlerMethodArgumentResolver.class, "LOGGER", actualLoggerSpy,
 				LogAccessor.class);
 
 		// Invoke twice but should only log the first time
-		assertThat(resolver.supportsParameter(parameter)).isTrue();
+		assertThat(resolver.supportsParameter(parameter)).isFalse();
 		verify(actualLoggerSpy, times(1)).warn(any(Supplier.class));
-		assertThat(resolver.supportsParameter(parameter)).isTrue();
+		assertThat(resolver.supportsParameter(parameter)).isFalse();
 		verifyNoMoreInteractions(actualLoggerSpy);
 	}
 
 	@ParameterizedTest // GH-3300
-	@ValueSource(strings = { "withProjectedPayload", "withAnnotatedInterface" })
+	@ValueSource(strings = { "withProjectedPayload", "withSpringAnnotatedInterface", "withUserAnnotatedInterface" })
 	void shouldNotLogDeprecationForValidUsage(String methodName) {
 
 		var parameter = getParameter(methodName);
@@ -152,7 +162,7 @@ void shouldNotLogDeprecationForValidUsage(String methodName) {
 		ReflectionTestUtils.setField(ProxyingHandlerMethodArgumentResolver.class, "LOGGER", actualLoggerSpy,
 				LogAccessor.class);
 
-		// Invoke twice but should only log the first time
+		// Invoke should not log
 		assertThat(resolver.supportsParameter(parameter)).isTrue();
 		verifyNoInteractions(actualLoggerSpy);
 	}
@@ -182,13 +192,13 @@ interface UnannotatedInterface {}
 
 	interface Controller {
 
-		void with(AnnotatedInterface param);
+		void withSpringAnnotatedInterface(AnnotatedInterface param);
 
-		void withAnnotatedInterface(@ModelAttribute AnnotatedInterface param);
+		void withSpringUnannotatedInterface(UnannotatedInterface param);
 
-		void with(UnannotatedInterface param);
+		void withUserAnnotatedInterface(ProjectedPayloadMarkedSampleInterface param);
 
-		void with(SampleInterface param);
+		void withUserUnannotatedInterface(SampleInterface param);
 
 		void with(List<Object> param);