Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consistently register CGLIB hints for lazy resolution proxy classes

Browse Source 
Core JDK/CGLIB proxy registration code extracted to ClassHintUtils.

Closes gh-29584
This commit is contained in:
Juergen Hoeller
2022-11-26 13:38:34 +01:00
parent 902f8dd1d8
commit 8e5eb84da1
4 changed files with 95 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
spring-beans/src/main/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.java
View File

@@ -25,7 +25,6 @@ import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -46,6 +45,7 @@ import org.springframework.aot.generate.GeneratedMethod;
import org.springframework.aot.generate.GenerationContext;
import org.springframework.aot.hint.ExecutableMode;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.support.ClassHintUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
@@ -1018,10 +1018,10 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
private void registerProxyIfNecessary(RuntimeHints runtimeHints, DependencyDescriptor dependencyDescriptor) {
if (this.candidateResolver != null) {
Class<?> proxyType =
Class<?> proxyClass =
this.candidateResolver.getLazyResolutionProxyClass(dependencyDescriptor, null);
if (proxyType != null && Proxy.isProxyClass(proxyType)) {
runtimeHints.proxies().registerJdkProxy(proxyType.getInterfaces());
if (proxyClass != null) {
ClassHintUtils.registerProxyIfNecessary(proxyClass, runtimeHints);
}
}
}

10
spring-context/src/main/java/org/springframework/context/aot/CglibClassHandler.java
View File

@@ -16,7 +16,6 @@
package org.springframework.context.aot;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import org.springframework.aot.generate.GeneratedFiles;
@@ -26,6 +25,7 @@ import org.springframework.aot.hint.MemberCategory;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.TypeHint.Builder;
import org.springframework.aot.hint.TypeReference;
import org.springframework.aot.hint.support.ClassHintUtils;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.core.io.ByteArrayResource;
@@ -34,8 +34,10 @@ import org.springframework.core.io.ByteArrayResource;
* and register the necessary hints so that they can be instantiated.
*
* @author Stephane Nicoll
* @see ReflectUtils#setGeneratedClassHandler(BiConsumer)
* @see ReflectUtils#setLoadedClassHandler(Consumer)
* @since 6.0
* @see ReflectUtils#setGeneratedClassHandler
* @see ReflectUtils#setLoadedClassHandler
* @see ClassHintUtils#registerProxyIfNecessary
*/
class CglibClassHandler {
@@ -46,11 +48,13 @@ class CglibClassHandler {
private final GeneratedFiles generatedFiles;
CglibClassHandler(GenerationContext generationContext) {
this.runtimeHints = generationContext.getRuntimeHints();
this.generatedFiles = generationContext.getGeneratedFiles();
}
/**
* Handle the specified generated CGLIB class.
* @param cglibClassName the name of the generated class

48
spring-context/src/main/java/org/springframework/context/support/GenericApplicationContext.java
View File

@@ -18,15 +18,12 @@ package org.springframework.context.support;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Proxy;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.springframework.aot.hint.MemberCategory;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.TypeHint.Builder;
import org.springframework.aot.hint.support.ClassHintUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanDefinitionStoreException;
@@ -49,7 +46,6 @@ import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.metrics.ApplicationStartup;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
/**
* Generic ApplicationContext implementation that holds a single internal
@@ -72,7 +68,7 @@ import org.springframework.util.ClassUtils;
* definitions on it. {@link #refresh()} may only be called once.
*
* <p>This ApplicationContext implementation is suitable for Ahead of Time
* processing, using {@link #refreshForAotProcessing()} as an alternative to the
* processing, using {@link #refreshForAotProcessing} as an alternative to the
* regular {@link #refresh()}.
*
* <p>Usage example:
@@ -88,16 +84,13 @@ import org.springframework.util.ClassUtils;
* MyBean myBean = (MyBean) ctx.getBean("myBean");
* ...</pre>
*
* For the typical case of XML bean definitions, simply use
* For the typical case of XML bean definitions, you may also use
* {@link ClassPathXmlApplicationContext} or {@link FileSystemXmlApplicationContext},
* which are easier to set up - but less flexible, since you can just use standard
* resource locations for XML bean definitions, rather than mixing arbitrary bean
* definition formats. The equivalent in a web environment is
* {@link org.springframework.web.context.support.XmlWebApplicationContext}.
*
* <p>For custom application context implementations that are supposed to read
* special bean definition formats in a refreshable manner, consider deriving
* from the {@link AbstractRefreshableApplicationContext} base class.
* definition formats. For a custom application context implementation supposed to
* read a specific bean definition format in a refreshable manner, consider
* deriving from the {@link AbstractRefreshableApplicationContext} base class.
*
* @author Juergen Hoeller
* @author Chris Beams
@@ -111,15 +104,6 @@ import org.springframework.util.ClassUtils;
*/
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
private static final Consumer<Builder> asClassBasedProxy = hint ->
hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
MemberCategory.INVOKE_DECLARED_METHODS,
MemberCategory.DECLARED_FIELDS);
private static final Consumer<Builder> asProxiedUserClass = hint ->
hint.withMembers(MemberCategory.INVOKE_PUBLIC_METHODS);
private final DefaultListableBeanFactory beanFactory;
@Nullable
@@ -442,11 +426,11 @@ public class GenericApplicationContext extends AbstractApplicationContext implem
for (String beanName : this.beanFactory.getBeanDefinitionNames()) {
Class<?> beanType = this.beanFactory.getType(beanName);
if (beanType != null) {
registerProxyHintIfNecessary(beanType, runtimeHints);
ClassHintUtils.registerProxyIfNecessary(beanType, runtimeHints);
for (SmartInstantiationAwareBeanPostProcessor bpp : bpps) {
Class<?> newBeanType = bpp.determineBeanType(beanType, beanName);
if (newBeanType != beanType) {
registerProxyHintIfNecessary(newBeanType, runtimeHints);
ClassHintUtils.registerProxyIfNecessary(newBeanType, runtimeHints);
beanType = newBeanType;
}
}
@@ -454,22 +438,6 @@ public class GenericApplicationContext extends AbstractApplicationContext implem
}
}
private void registerProxyHintIfNecessary(Class<?> beanType, RuntimeHints runtimeHints) {
if (Proxy.isProxyClass(beanType)) {
// A JDK proxy class needs an explicit hint
runtimeHints.proxies().registerJdkProxy(beanType.getInterfaces());
}
else {
// Potentially a CGLIB-generated subclass with reflection hints
Class<?> userClass = ClassUtils.getUserClass(beanType);
if (userClass != beanType) {
runtimeHints.reflection()
.registerType(beanType, asClassBasedProxy)
.registerType(userClass, asProxiedUserClass);
}
}
}
//---------------------------------------------------------------------
// Convenient methods for registering individual beans

76
spring-core/src/main/java/org/springframework/aot/hint/support/ClassHintUtils.java Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright 2002-2022 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.
*/
package org.springframework.aot.hint.support;
import java.lang.reflect.Proxy;
import java.util.function.Consumer;
import org.springframework.aot.hint.MemberCategory;
import org.springframework.aot.hint.RuntimeHints;
import org.springframework.aot.hint.TypeHint;
import org.springframework.util.ClassUtils;
/**
* Utilities for core hint inference on Spring-managed classes,
* specifically for proxy types such as interface-based JDK proxies
* and CGLIB-generated subclasses which need proxy/reflection hints.
*
* <p>Note that this class does not take specifics of Spring AOP or
* any other framework arrangement into account. It just operates
* on the JDK and CGLIB proxy facilities and their core conventions.
*
* @author Juergen Hoeller
* @since 6.0.3
* @see org.springframework.aot.hint.ProxyHints
* @see org.springframework.aot.hint.ReflectionHints
*/
public abstract class ClassHintUtils {
private static final Consumer<TypeHint.Builder> asClassBasedProxy = hint ->
hint.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
MemberCategory.INVOKE_DECLARED_METHODS,
MemberCategory.DECLARED_FIELDS);
private static final Consumer<TypeHint.Builder> asProxiedUserClass = hint ->
hint.withMembers(MemberCategory.INVOKE_PUBLIC_METHODS);
/**
* Register a proxy hint for a JDK proxy or corresponding reflection hints
* for a CGLIB-generated subclass, if necessary.
* @param candidateClass the class to introspect
* @param runtimeHints the RuntimeHints instance to register the hints on
* @see Proxy#isProxyClass(Class)
* @see ClassUtils#getUserClass(Class)
*/
public static void registerProxyIfNecessary(Class<?> candidateClass, RuntimeHints runtimeHints) {
if (Proxy.isProxyClass(candidateClass)) {
// A JDK proxy class needs an explicit hint
runtimeHints.proxies().registerJdkProxy(candidateClass.getInterfaces());
}
else {
// Potentially a CGLIB-generated subclass with reflection hints
Class<?> userClass = ClassUtils.getUserClass(candidateClass);
if (userClass != candidateClass) {
runtimeHints.reflection()
.registerType(candidateClass, asClassBasedProxy)
.registerType(userClass, asProxiedUserClass);
}
}
}
}