Remove specific JDK dynamic proxy configuration

Further refinements will be required for
MethodValidationPostProcessor since @lazy
used by Spring Boot is not supported yet
for that use case.

See spring-projectsgh-28980

Author: sdeleuze

spring-context/src/main/java/org/springframework/cache/annotation/CachingBeanRegistrationAotProcessor.java

@@ -23,19 +23,14 @@
 import org.aopalliance.aop.Advice;
 
 import org.springframework.aop.Pointcut;
-import org.springframework.aop.framework.AopProxyUtils;
 import org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor;
 import org.springframework.aop.support.DefaultPointcutAdvisor;
 import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
-import org.springframework.aot.hint.RuntimeHints;
-import org.springframework.aot.hint.RuntimeHintsRegistrar;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.config.BeanPostProcessor;
-import org.springframework.context.annotation.ImportRuntimeHints;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.validation.annotation.Validated;
-import org.springframework.validation.beanvalidation.MethodValidationPostProcessor.MethodValidationRuntimeHints;
 
 /**
  * A convenient {@link BeanPostProcessor} implementation that delegates to a
@@ -62,7 +57,6 @@
  * @see jakarta.validation.executable.ExecutableValidator
  */
 @SuppressWarnings("serial")
-@ImportRuntimeHints(MethodValidationRuntimeHints.class)
 public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor
 		implements InitializingBean {
 
@@ -131,14 +125,4 @@ protected Advice createMethodValidationAdvice(@Nullable Validator validator) {
 		return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor());
 	}
 
-
-	static class MethodValidationRuntimeHints implements RuntimeHintsRegistrar {
-
-		@Override
-		public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
-			hints.proxies().registerJdkProxy(AopProxyUtils.completeJdkProxyInterfaces(Validator.class));
-		}
-
-	}
-
 }

spring-context/src/main/java/org/springframework/validation/beanvalidation/MethodValidationPostProcessor.java

@@ -1,5 +1,3 @@
 org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor= \
 org.springframework.context.aot.ReflectiveProcessorBeanFactoryInitializationAotProcessor
 
-org.springframework.beans.factory.aot.BeanRegistrationAotProcessor= \
-org.springframework.cache.annotation.CachingBeanRegistrationAotProcessor

spring-context/src/main/resources/META-INF/spring/aot.factories

@@ -20,7 +20,6 @@
 import java.util.LinkedHashSet;
 import java.util.Set;
 
-import org.springframework.aop.framework.AopProxyUtils;
 import org.springframework.aot.generate.GenerationContext;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.RuntimeHints;
@@ -35,7 +34,7 @@
 /**
  * AOT {@code BeanRegistrationAotProcessor} that detects the presence of
  * {@link Transactional @Transactional} on annotated elements and creates
- * the required proxy and reflection hints.
+ * the required reflection hints.
  *
  * @author Sebastien Deleuze
  * @since 6.0
@@ -89,7 +88,6 @@ public void applyTo(GenerationContext generationContext, BeanRegistrationCode be
 				runtimeHints.reflection().registerType(proxyInterface,
 						builder -> builder.withMembers(MemberCategory.INVOKE_DECLARED_METHODS));
 			}
-			runtimeHints.proxies().registerJdkProxy(AopProxyUtils.completeJdkProxyInterfaces(proxyInterfaces));
 		}
 	}
 

spring-context/src/test/java/org/springframework/cache/annotation/CachingBeanRegistrationAotProcessorTests.java

@@ -18,8 +18,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import org.springframework.aop.SpringProxy;
-import org.springframework.aop.framework.Advised;
 import org.springframework.aot.generate.GenerationContext;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;
@@ -28,7 +26,6 @@
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RegisteredBean;
 import org.springframework.beans.factory.support.RootBeanDefinition;
-import org.springframework.core.DecoratingProxy;
 import org.springframework.core.testfixture.aot.generate.TestGenerationContext;
 import org.springframework.lang.Nullable;
 
@@ -50,54 +47,47 @@ public class TransactionBeanRegistrationAotProcessorTests {
 	void shouldSkipNonAnnotatedType() {
 		process(NonAnnotatedBean.class);
 		assertThat(this.generationContext.getRuntimeHints().reflection().typeHints()).isEmpty();
-		assertThat(this.generationContext.getRuntimeHints().proxies().jdkProxies()).isEmpty();
 	}
 
 	@Test
 	void shouldSkipAnnotatedTypeWithNoInterface() {
 		process(NoInterfaceBean.class);
 		assertThat(this.generationContext.getRuntimeHints().reflection().typeHints()).isEmpty();
-		assertThat(this.generationContext.getRuntimeHints().proxies().jdkProxies()).isEmpty();
 	}
 
 	@Test
 	void shouldProcessTransactionalOnClass() {
 		process(TransactionalOnTypeBean.class);
 		assertThat(RuntimeHintsPredicates.reflection().onType(NonAnnotatedTransactionalInterface.class)
 				.withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(this.generationContext.getRuntimeHints());
-		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(NonAnnotatedTransactionalInterface.class, SpringProxy.class, Advised.class, DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints());
 	}
 
 	@Test
 	void shouldProcessJakartaTransactionalOnClass() {
 		process(JakartaTransactionalOnTypeBean.class);
 		assertThat(RuntimeHintsPredicates.reflection().onType(NonAnnotatedTransactionalInterface.class)
 				.withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(this.generationContext.getRuntimeHints());
-		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(NonAnnotatedTransactionalInterface.class, SpringProxy.class, Advised.class, DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints());
 	}
 
 	@Test
 	void shouldProcessTransactionalOnInterface() {
 		process(TransactionalOnTypeInterface.class);
 		assertThat(RuntimeHintsPredicates.reflection().onType(TransactionalOnTypeInterface.class)
 				.withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(this.generationContext.getRuntimeHints());
-		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(TransactionalOnTypeInterface.class, SpringProxy.class, Advised.class, DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints());
 	}
 
 	@Test
 	void shouldProcessTransactionalOnClassMethod() {
 		process(TransactionalOnClassMethodBean.class);
 		assertThat(RuntimeHintsPredicates.reflection().onType(NonAnnotatedTransactionalInterface.class)
 				.withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(this.generationContext.getRuntimeHints());
-		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(NonAnnotatedTransactionalInterface.class, SpringProxy.class, Advised.class, DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints());
 	}
 
 	@Test
 	void shouldProcessTransactionalOnInterfaceMethod() {
 		process(TransactionalOnInterfaceMethodBean.class);
 		assertThat(RuntimeHintsPredicates.reflection().onType(TransactionalOnMethodInterface.class)
 				.withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(this.generationContext.getRuntimeHints());
-		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(TransactionalOnMethodInterface.class, SpringProxy.class, Advised.class, DecoratingProxy.class)).accepts(this.generationContext.getRuntimeHints());
 	}
 
 	private void process(Class<?> beanClass) {