Perform basic property determination without java.beans.Introspector

Closes gh-29320

Author: jhoeller

spring-beans/src/main/java/org/springframework/beans/CachedIntrospectionResults.java

@@ -18,12 +18,13 @@
 
 import java.beans.BeanInfo;
 import java.beans.IntrospectionException;
-import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
+import java.beans.SimpleBeanInfo;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.net.URL;
 import java.security.ProtectionDomain;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -36,7 +37,6 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
-import org.springframework.core.SpringProperties;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.io.support.SpringFactoriesLoader;
 import org.springframework.lang.Nullable;
@@ -60,14 +60,15 @@
  * <p>Note that for caching to work effectively, some preconditions need to be met:
  * Prefer an arrangement where the Spring jars live in the same ClassLoader as the
  * application classes, which allows for clean caching along with the application's
- * lifecycle in any case. For a web application, consider declaring a local
- * {@link org.springframework.web.util.IntrospectorCleanupListener} in {@code web.xml}
- * in case of a multi-ClassLoader layout, which will allow for effective caching as well.
+ * lifecycle in any case.
  *
- * <p>In case of a non-clean ClassLoader arrangement without a cleanup listener having
- * been set up, this class will fall back to a weak-reference-based caching model that
- * recreates much-requested entries every time the garbage collector removed them. In
- * such a scenario, consider the {@link #IGNORE_BEANINFO_PROPERTY_NAME} system property.
+ * <p>As of 6.0, Spring's default introspection discovers basic JavaBeans properties
+ * through an efficient method reflection pass. For full JavaBeans introspection
+ * including indexed properties and all JDK-supported customizers, configure a
+ * {@code META-INF/spring.factories} file with the following content:
+ * {@code org.springframework.beans.BeanInfoFactory=org.springframework.beans.StandardBeanInfoFactory}
+ * For Spring 5.3 compatible extended introspection including non-void setter methods:
+ * {@code org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory}
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
@@ -78,32 +79,9 @@
  */
 public final class CachedIntrospectionResults {
 
-	/**
-	 * System property that instructs Spring to use the {@link Introspector#IGNORE_ALL_BEANINFO}
-	 * mode when calling the JavaBeans {@link Introspector}: "spring.beaninfo.ignore", with a
-	 * value of "true" skipping the search for {@code BeanInfo} classes (typically for scenarios
-	 * where no such classes are being defined for beans in the application in the first place).
-	 * <p>The default is "false", considering all {@code BeanInfo} metadata classes, like for
-	 * standard {@link Introspector#getBeanInfo(Class)} calls. Consider switching this flag to
-	 * "true" if you experience repeated ClassLoader access for non-existing {@code BeanInfo}
-	 * classes, in case such access is expensive on startup or on lazy loading.
-	 * <p>Note that such an effect may also indicate a scenario where caching doesn't work
-	 * effectively: Prefer an arrangement where the Spring jars live in the same ClassLoader
-	 * as the application classes, which allows for clean caching along with the application's
-	 * lifecycle in any case. For a web application, consider declaring a local
-	 * {@link org.springframework.web.util.IntrospectorCleanupListener} in {@code web.xml}
-	 * in case of a multi-ClassLoader layout, which will allow for effective caching as well.
-	 * @see Introspector#getBeanInfo(Class, int)
-	 */
-	public static final String IGNORE_BEANINFO_PROPERTY_NAME = "spring.beaninfo.ignore";
-
 	private static final PropertyDescriptor[] EMPTY_PROPERTY_DESCRIPTOR_ARRAY = {};
 
 
-	private static final boolean shouldIntrospectorIgnoreBeaninfoClasses =
-			SpringProperties.getFlag(IGNORE_BEANINFO_PROPERTY_NAME);
-
-	/** Stores the BeanInfoFactory instances. */
 	private static final List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
 			BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
 
@@ -241,7 +219,7 @@ private static boolean isUnderneathClassLoader(@Nullable ClassLoader candidate,
 	 * Retrieve a {@link BeanInfo} descriptor for the given target class.
 	 * @param beanClass the target class to introspect
 	 * @return the resulting {@code BeanInfo} descriptor (never {@code null})
-	 * @throws IntrospectionException from the underlying {@link Introspector}
+	 * @throws IntrospectionException from introspecting the given bean class
 	 */
 	private static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException {
 		for (BeanInfoFactory beanInfoFactory : beanInfoFactories) {
@@ -250,9 +228,14 @@ private static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionExce
 				return beanInfo;
 			}
 		}
-		return (shouldIntrospectorIgnoreBeaninfoClasses ?
-				Introspector.getBeanInfo(beanClass, Introspector.IGNORE_ALL_BEANINFO) :
-				Introspector.getBeanInfo(beanClass));
+
+		Collection<PropertyDescriptor> pds = PropertyDescriptorUtils.determineBasicProperties(beanClass);
+		return new SimpleBeanInfo() {
+			@Override
+			public PropertyDescriptor[] getPropertyDescriptors() {
+				return pds.toArray(EMPTY_PROPERTY_DESCRIPTOR_ARRAY);
+			}
+		};
 	}
 
 

spring-beans/src/main/java/org/springframework/beans/ExtendedBeanInfoFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * 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.
@@ -18,34 +18,35 @@
 
 import java.beans.BeanInfo;
 import java.beans.IntrospectionException;
-import java.beans.Introspector;
 import java.lang.reflect.Method;
 
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
+import org.springframework.lang.NonNull;
 
 /**
- * {@link BeanInfoFactory} implementation that evaluates whether bean classes have
- * "non-standard" JavaBeans setter methods and are thus candidates for introspection
- * by Spring's (package-visible) {@code ExtendedBeanInfo} implementation.
+ * Extension of {@link StandardBeanInfoFactory} that supports "non-standard"
+ * JavaBeans setter methods through introspection by Spring's
+ * (package-visible) {@code ExtendedBeanInfo} implementation.
+ *
+ * <p>To be configured via a {@code META-INF/spring.factories} file with the following content:
+ * {@code org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory}
  *
  * <p>Ordered at {@link Ordered#LOWEST_PRECEDENCE} to allow other user-defined
  * {@link BeanInfoFactory} types to take precedence.
  *
  * @author Chris Beams
+ * @author Juergen Hoeller
  * @since 3.2
- * @see BeanInfoFactory
+ * @see StandardBeanInfoFactory
  * @see CachedIntrospectionResults
  */
-public class ExtendedBeanInfoFactory implements BeanInfoFactory, Ordered {
+public class ExtendedBeanInfoFactory extends StandardBeanInfoFactory {
 
-	/**
-	 * Return an {@link ExtendedBeanInfo} for the given bean class, if applicable.
-	 */
 	@Override
-	@Nullable
+	@NonNull
 	public BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException {
-		return (supports(beanClass) ? new ExtendedBeanInfo(Introspector.getBeanInfo(beanClass)) : null);
+		BeanInfo beanInfo = super.getBeanInfo(beanClass);
+		return (supports(beanClass) ? new ExtendedBeanInfo(beanInfo) : beanInfo);
 	}
 
 	/**
@@ -61,9 +62,4 @@ private boolean supports(Class<?> beanClass) {
 		return false;
 	}
 
-	@Override
-	public int getOrder() {
-		return Ordered.LOWEST_PRECEDENCE;
-	}
-
 }

spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * 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.
@@ -19,10 +19,14 @@
 import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Method;
+import java.util.Collection;
 import java.util.Enumeration;
+import java.util.Map;
+import java.util.TreeMap;
 
 import org.springframework.lang.Nullable;
 import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
 
 /**
  * Common delegate methods for Spring's internal {@link PropertyDescriptor} implementations.
@@ -32,6 +36,82 @@
  */
 abstract class PropertyDescriptorUtils {
 
+	/**
+	 * Simple introspection algorithm for basic set/get/is accessor methods,
+	 * building corresponding JavaBeans property descriptors for them.
+	 * <p>This just supports the basic JavaBeans conventions, without indexed
+	 * properties or any customizers, and without other BeanInfo metadata.
+	 * For standard JavaBeans introspection, use the JavaBeans Introspector.
+	 * @param beanClass the target class to introspect
+	 * @return a collection of property descriptors
+	 * @throws IntrospectionException from introspecting the given bean class
+	 * @since 6.0
+	 * @see java.beans.Introspector#getBeanInfo(Class)
+	 */
+	public static Collection<PropertyDescriptor> determineBasicProperties(Class<?> beanClass) throws IntrospectionException {
+		Map<String, PropertyDescriptor> pdMap = new TreeMap<>();
+
+		for (Method method : beanClass.getMethods()) {
+			String methodName = method.getName();
+			boolean setter;
+			int nameIndex;
+			if (methodName.startsWith("set") && method.getParameterCount() == 1) {
+				setter = true;
+				nameIndex = 3;
+			}
+			else if (methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != Void.TYPE) {
+				setter = false;
+				nameIndex = 3;
+			}
+			else if (methodName.startsWith("is") && method.getParameterCount() == 0 && method.getReturnType() == boolean.class) {
+				setter = false;
+				nameIndex = 2;
+			}
+			else {
+				continue;
+			}
+
+			String propertyName = StringUtils.uncapitalizeAsProperty(methodName.substring(nameIndex));
+			PropertyDescriptor pd = pdMap.get(propertyName);
+			if (pd != null) {
+				if (setter) {
+					if (pd.getWriteMethod() == null ||
+							pd.getWriteMethod().getParameterTypes()[0].isAssignableFrom(method.getParameterTypes()[0])) {
+						try {
+							pd.setWriteMethod(method);
+						}
+						catch (IntrospectionException ex) {
+							// typically a type mismatch -> ignore
+						}
+					}
+				}
+				else {
+					if (pd.getReadMethod() == null ||
+							(pd.getReadMethod().getReturnType() == method.getReturnType() && method.getName().startsWith("is"))) {
+						try {
+							pd.setReadMethod(method);
+						}
+						catch (IntrospectionException ex) {
+							// typically a type mismatch -> ignore
+						}
+					}
+				}
+			}
+			else {
+				pd = new BasicPropertyDescriptor(propertyName, beanClass);
+				if (setter) {
+					pd.setWriteMethod(method);
+				}
+				else {
+					pd.setReadMethod(method);
+				}
+				pdMap.put(propertyName, pd);
+			}
+		}
+
+		return pdMap.values();
+	}
+
 	/**
 	 * See {@link java.beans.FeatureDescriptor}.
 	 */
@@ -173,4 +253,45 @@ public static boolean equals(PropertyDescriptor pd, PropertyDescriptor otherPd)
 				pd.isBound() == otherPd.isBound() && pd.isConstrained() == otherPd.isConstrained());
 	}
 
+
+	/**
+	 * PropertyDescriptor for {@link #determineBasicProperties(Class)},
+	 * not performing any early type determination for
+	 * {@link #setReadMethod}/{@link #setWriteMethod}.
+	 */
+	private static class BasicPropertyDescriptor extends PropertyDescriptor {
+
+		@Nullable
+		private Method readMethod;
+
+		@Nullable
+		private Method writeMethod;
+
+		public BasicPropertyDescriptor(String propertyName, Class<?> beanClass) throws IntrospectionException {
+			super(propertyName, beanClass, null, null);
+		}
+
+		@Override
+		public void setReadMethod(@Nullable Method readMethod) {
+			this.readMethod = readMethod;
+		}
+
+		@Override
+		@Nullable
+		public Method getReadMethod() {
+			return this.readMethod;
+		}
+
+		@Override
+		public void setWriteMethod(@Nullable Method writeMethod) {
+			this.writeMethod = writeMethod;
+		}
+
+		@Override
+		@Nullable
+		public Method getWriteMethod() {
+			return this.writeMethod;
+		}
+	}
+
 }