Stop implementing SynthesizedAnnotation in annotation proxies

SynthesizedAnnotation was originally introduced as a convenience for
easily detecting if an annotation had been synthesized by Spring via a
simple `if (myAnnotation instanceof SynthesizedAnnotation)` check.

However, the introduction of SynthesizedAnnotation in the JDK dynamic
proxy for a synthesized annotation results in a separate proxy class
for each annotation synthesized by Spring, and this causes issues with
GraalVM native images since users and framework developers must always
ensure that the additional proxy classes are registered.

This commit completely removes the use of SynthesizedAnnotation in
synthesized annotation proxies. This change allows the proxy class for
an annotation to be reused for a synthesized annotation of the same
annotation type.

Consequently:

- Extra proxy classes are not generated on the JVM or in a native image.
- Extra proxy classes are not required to be registered for a native image.

Closes gh-29041

Author: sbrannen

spring-core/src/main/java/org/springframework/aot/hint/support/RuntimeHintsUtils.java

@@ -49,7 +49,6 @@ public abstract class RuntimeHintsUtils {
 	 * at runtime.
 	 * @param hints the {@link RuntimeHints} instance to use
 	 * @param annotationType the annotation type
-	 * @see SynthesizedAnnotation
 	 * @deprecated as annotation attributes are visible without additional hints
 	 */
 	@Deprecated
@@ -70,7 +69,6 @@ public static void registerAnnotation(RuntimeHints hints, Class<?> annotationTyp
 	 * that determines if the hints are required.
 	 * @param hints the {@link RuntimeHints} instance to use
 	 * @param annotationType the annotation type
-	 * @see SynthesizedAnnotation
 	 */
 	public static void registerSynthesizedAnnotation(RuntimeHints hints, Class<?> annotationType) {
 		hints.proxies().registerJdkProxy(annotationType, SynthesizedAnnotation.class);

spring-core/src/main/java/org/springframework/core/annotation/AnnotationUtils.java

@@ -22,6 +22,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -1288,7 +1289,15 @@ static Annotation[] synthesizeAnnotationArray(Annotation[] annotations, Annotate
 	 * @since 5.3.23
 	 */
 	public static boolean isSynthesizedAnnotation(@Nullable Annotation annotation) {
-		return (annotation instanceof SynthesizedAnnotation);
+		try {
+			return ((annotation != null) && Proxy.isProxyClass(annotation.getClass()) &&
+					(Proxy.getInvocationHandler(annotation) instanceof SynthesizedMergedAnnotationInvocationHandler));
+		}
+		catch (SecurityException ex) {
+			// Security settings disallow reflective access to the InvocationHandler:
+			// assume the annotation has not been synthesized by Spring.
+			return false;
+		}
 	}
 
 	/**

spring-core/src/main/java/org/springframework/core/annotation/SynthesizedMergedAnnotationInvocationHandler.java

@@ -299,9 +299,8 @@ private Object cloneArray(Object array) {
 	@SuppressWarnings("unchecked")
 	static <A extends Annotation> A createProxy(MergedAnnotation<A> annotation, Class<A> type) {
 		ClassLoader classLoader = type.getClassLoader();
+		Class<?>[] interfaces = new Class<?>[] {type};
 		InvocationHandler handler = new SynthesizedMergedAnnotationInvocationHandler<>(annotation, type);
-		Class<?>[] interfaces = isVisible(classLoader, SynthesizedAnnotation.class) ?
-				new Class<?>[] {type, SynthesizedAnnotation.class} : new Class<?>[] {type};
 		return (A) Proxy.newProxyInstance(classLoader, interfaces, handler);
 	}
 
@@ -310,17 +309,4 @@ private static String getName(Class<?> clazz) {
 		return (canonicalName != null ? canonicalName : clazz.getName());
 	}
 
-
-	private static boolean isVisible(ClassLoader classLoader, Class<?> interfaceClass) {
-		if (classLoader == interfaceClass.getClassLoader()) {
-			return true;
-		}
-		try {
-			return Class.forName(interfaceClass.getName(), false, classLoader) == interfaceClass;
-		}
-		catch (ClassNotFoundException ex) {
-			return false;
-		}
-	}
-
 }

spring-core/src/main/java/org/springframework/core/annotation/TypeMappedAnnotation.java

@@ -363,7 +363,7 @@ private boolean isTargetAnnotation(@Nullable Object obj) {
 	 * @since 5.3.22
 	 */
 	private boolean isSynthesizable(Annotation annotation) {
-		if (annotation instanceof SynthesizedAnnotation) {
+		if (AnnotationUtils.isSynthesizedAnnotation(annotation)) {
 			return false;
 		}
 		return isSynthesizable();

spring-core/src/test/java/org/springframework/core/annotation/MergedAnnotationsTests.java

@@ -1511,6 +1511,26 @@ void isSynthesizableWithoutAttributeAliases() throws Exception {
 		assertThat(MergedAnnotation.from(component).isSynthesizable()).isFalse();
 	}
 
+	/**
+	 * @since 6.0
+	 */
+	@Test
+	void synthesizedAnnotationShouldReuseJdkProxyClass() throws Exception {
+		Method method = WebController.class.getMethod("handleMappedWithValueAttribute");
+
+		RequestMapping jdkRequestMapping = method.getAnnotation(RequestMapping.class);
+		assertThat(jdkRequestMapping).isNotNull();
+		assertThat(jdkRequestMapping.value()).containsExactly("/test");
+		assertThat(jdkRequestMapping.path()).containsExactly("");
+
+		RequestMapping synthesizedRequestMapping = MergedAnnotation.from(jdkRequestMapping).synthesize();
+		assertSynthesized(synthesizedRequestMapping);
+		assertThat(synthesizedRequestMapping.value()).containsExactly("/test");
+		assertThat(synthesizedRequestMapping.path()).containsExactly("/test");
+
+		assertThat(jdkRequestMapping.getClass()).isSameAs(synthesizedRequestMapping.getClass());
+	}
+
 	@Test
 	void synthesizeAlreadySynthesized() throws Exception {
 		Method method = WebController.class.getMethod("handleMappedWithValueAttribute");
@@ -1585,7 +1605,6 @@ void synthesizeShouldNotSynthesizeNonsynthesizableAnnotationsWhenUsingMergedAnno
 				mergedAnnotations.get(EnableGlobalAuthentication.class);
 		assertThat(enableGlobalAuthenticationMergedAnnotation.isSynthesizable()).isFalse();
 		EnableGlobalAuthentication enableGlobalAuthentication = enableGlobalAuthenticationMergedAnnotation.synthesize();
-		assertThat(enableGlobalAuthentication).isNotInstanceOf(SynthesizedAnnotation.class);
 		assertNotSynthesized(enableGlobalAuthentication);
 	}