HHH-20148 Avoid depending on module java.desktop (hibernate#11768)

* HHH-20148 Avoid depending on module java.desktop

+ Reconfigure the compiler to disallow the java.desktop module

---------

Co-authored-by: Sanne Grinovero <sanne@commonhaus.dev>

Author: Sanne

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlProcessingHelper.java

@@ -4,12 +4,12 @@
  */
 package org.hibernate.boot.models.xml.internal;
 
-import java.beans.Introspector;
-
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappingsImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbManagedType;
 import org.hibernate.boot.models.MemberResolutionException;
 import org.hibernate.internal.util.StringHelper;
+
+import static org.hibernate.internal.util.StringHelper.decapitalize;
 import org.hibernate.models.spi.FieldDetails;
 import org.hibernate.models.spi.MethodDetails;
 import org.hibernate.models.spi.MutableClassDetails;
@@ -74,14 +74,14 @@ public static MutableMemberDetails findAttributeMember(
 				if ( methodDetails.getMethodKind() == MethodDetails.MethodKind.GETTER ) {
 					if ( methodDetails.getName().startsWith( "get" ) ) {
 						final String stemName = methodDetails.getName().substring( 3 );
-						final String decapitalizedStemName = Introspector.decapitalize( stemName );
+						final String decapitalizedStemName = decapitalize( stemName );
 						if ( stemName.equals( attributeName ) || decapitalizedStemName.equals( attributeName ) ) {
 							return (MutableMemberDetails) methodDetails;
 						}
 					}
 					else if ( methodDetails.getName().startsWith( "is" ) ) {
 						final String stemName = methodDetails.getName().substring( 2 );
-						final String decapitalizedStemName = Introspector.decapitalize( stemName );
+						final String decapitalizedStemName = decapitalize( stemName );
 						if ( stemName.equals( attributeName ) || decapitalizedStemName.equals( attributeName ) ) {
 							return (MutableMemberDetails) methodDetails;
 						}

hibernate-core/src/main/java/org/hibernate/internal/util/ReflectHelper.java

@@ -30,7 +30,7 @@
 
 import jakarta.persistence.Transient;
 
-import static java.beans.Introspector.decapitalize;
+import static org.hibernate.internal.util.StringHelper.decapitalize;
 import static java.lang.Character.isLowerCase;
 import static java.lang.Thread.currentThread;
 

hibernate-core/src/main/java/org/hibernate/internal/util/StringHelper.java

@@ -922,4 +922,37 @@ public static String safeInterning(final String string) {
 		return string == null ? null : string.intern();
 	}
 
+	/**
+	 * Converts a string to normal Java variable name capitalization following
+	 * the JavaBeans Introspector rules. This normally means converting the first
+	 * character from upper case to lower case, but in the (unusual) special case
+	 * when there is more than one character and both the first and second characters
+	 * are upper case, we leave it alone.
+	 * <p>
+	 * Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays as "URL".
+	 * <p>
+	 * This is a reimplementation of {@code java.beans.Introspector.decapitalize()}
+	 * to avoid pulling in the java.desktop module dependency.
+	 *
+	 * @param name The string to be decapitalized.
+	 * @return The decapitalized version of the string.
+	 */
+	public static String decapitalize(final String name) {
+		if ( name == null || name.isEmpty() ) {
+			return name;
+		}
+		final char firstChar = name.charAt( 0 );
+		// Already lowercase - return as-is to avoid allocation
+		if ( Character.isLowerCase( firstChar ) ) {
+			return name;
+		}
+		// Both first and second chars uppercase - return unchanged per JavaBeans spec
+		if ( name.length() > 1 && Character.isUpperCase( name.charAt( 1 ) ) ) {
+			return name;
+		}
+		final char[] chars = name.toCharArray();
+		chars[0] = Character.toLowerCase( firstChar );
+		return new String( chars );
+	}
+
 }

hibernate-core/src/main/java/org/hibernate/internal/util/beans/BeanInfo.java

@@ -0,0 +1,20 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.internal.util.beans;
+
+/**
+ * Describes the properties of a JavaBean.
+ * This is a reimplementation to avoid dependency on the {@code java.desktop} module.
+ */
+public interface BeanInfo {
+	/**
+	 * Returns an array of {@link PropertyDescriptor}s describing the
+	 * editable properties of the bean.
+	 *
+	 * @return An array of PropertyDescriptor objects, or null if the
+	 *         information should be obtained by automatic analysis.
+	 */
+	PropertyDescriptor[] getPropertyDescriptors();
+}

hibernate-core/src/main/java/org/hibernate/internal/util/beans/BeanInfoHelper.java

@@ -3,17 +3,49 @@
  * Copyright Red Hat Inc. and Hibernate Authors
  */
 package org.hibernate.internal.util.beans;
-import java.beans.BeanInfo;
-import java.beans.IntrospectionException;
-import java.beans.Introspector;
+
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.hibernate.internal.util.StringHelper.decapitalize;
 
 /**
- * Utility for helping deal with {@link BeanInfo}
+ * Utility for helping deal with {@link BeanInfo}.
+ * <p>
+ * This is a simplified reimplementation to avoid dependency on the {@code java.desktop} module.
+ * Unlike the JDK's {@code java.beans.Introspector}, this implementation:
+ * <ul>
+ *   <li>Does not validate type compatibility between getters and setters</li>
+ *   <li>Does not introspect methods from implemented interfaces (only class hierarchy)</li>
+ *   <li>Takes the first matching setter when overloads exist</li>
+ * </ul>
+ * These simplifications are acceptable for Hibernate's use case of property-name-based injection.
+ * <p>
+ * Caching is implemented using {@link ClassValue}, which is the JVM's built-in mechanism for
+ * associating computed values with classes. Unlike the JDK's {@code Introspector} cache, this
+ * approach is inherently GC-friendly: when a class is unloaded, the associated {@link BeanInfo}
+ * is automatically released, preventing classloader leaks without requiring explicit cache flushing.
  *
  * @author Steve Ebersole
  */
 public class BeanInfoHelper {
+
+	/**
+	 * Cache of BeanInfo instances, keyed by class.
+	 * Uses ClassValue which automatically handles class unloading - when a class is GC'd,
+	 * its associated BeanInfo is also released, preventing classloader leaks.
+	 * This cache is for the common case where stopClass is null (introspect up to Object).
+	 */
+	private static final ClassValue<BeanInfo> BEAN_INFO_CACHE = new ClassValue<>() {
+		@Override
+		protected BeanInfo computeValue(final Class<?> type) {
+			return computeBeanInfo( type, null );
+		}
+	};
+
 	public interface BeanInfoDelegate {
 		void processBeanInfo(BeanInfo beanInfo) throws Exception;
 	}
@@ -48,7 +80,7 @@ public static void visitBeanInfo(Class<?> beanClass, BeanInfoDelegate delegate)
 
 	public static void visitBeanInfo(Class<?> beanClass, Class<?> stopClass, BeanInfoDelegate delegate) {
 		try {
-			BeanInfo info = Introspector.getBeanInfo( beanClass, stopClass );
+			final BeanInfo info = getBeanInfo( beanClass, stopClass );
 			try {
 				delegate.processBeanInfo( info );
 			}
@@ -61,11 +93,11 @@ public static void visitBeanInfo(Class<?> beanClass, Class<?> stopClass, BeanInf
 			catch ( Exception e ) {
 				throw new BeanIntrospectionException( "Error delegating bean info use", e );
 			}
-			finally {
-				Introspector.flushFromCaches( beanClass );
-			}
 		}
-		catch ( IntrospectionException e ) {
+		catch ( BeanIntrospectionException e ) {
+			throw e;
+		}
+		catch ( Exception e ) {
 			throw new BeanIntrospectionException( "Unable to determine bean info from class [" + beanClass.getName() + "]", e );
 		}
 	}
@@ -76,7 +108,7 @@ public static <T> T visitBeanInfo(Class<?> beanClass, ReturningBeanInfoDelegate<
 
 	public static <T> T visitBeanInfo(Class<?> beanClass, Class<?> stopClass, ReturningBeanInfoDelegate<T> delegate) {
 		try {
-			BeanInfo info = Introspector.getBeanInfo( beanClass, stopClass );
+			final BeanInfo info = getBeanInfo( beanClass, stopClass );
 			try {
 				return delegate.processBeanInfo( info );
 			}
@@ -89,14 +121,126 @@ public static <T> T visitBeanInfo(Class<?> beanClass, Class<?> stopClass, Return
 			catch ( Exception e ) {
 				throw new BeanIntrospectionException( "Error delegating bean info use", e );
 			}
-			finally {
-				Introspector.flushFromCaches( beanClass );
-			}
 		}
-		catch ( IntrospectionException e ) {
+		catch ( BeanIntrospectionException e ) {
+			throw e;
+		}
+		catch ( Exception e ) {
 			throw new BeanIntrospectionException( "Unable to determine bean info from class [" + beanClass.getName() + "]", e );
 		}
 	}
 
+	/**
+	 * Introspect a JavaBean and return a BeanInfo object describing its properties.
+	 * This method walks up the class hierarchy to collect all properties.
+	 * <p>
+	 * Results are cached using {@link ClassValue} for the common case where stopClass is null.
+	 * The cache is GC-friendly and does not cause classloader leaks.
+	 *
+	 * @param beanClass The class to introspect
+	 * @param stopClass The base class at which to stop the analysis. Any methods
+	 *                  declared in the stopClass or its superclasses will be ignored.
+	 *                  May be null.
+	 * @return A BeanInfo object describing the target bean
+	 */
+	public static BeanInfo getBeanInfo(final Class<?> beanClass, final Class<?> stopClass) {
+		// Use cache for the common case (stopClass == null means introspect up to Object)
+		if ( stopClass == null ) {
+			return BEAN_INFO_CACHE.get( beanClass );
+		}
+		// Non-null stopClass is rare; compute without caching to keep cache simple
+		return computeBeanInfo( beanClass, stopClass );
+	}
+
+	private static BeanInfo computeBeanInfo(final Class<?> beanClass, final Class<?> stopClass) {
+		// LinkedHashMap for reproducible ordering (important for build-time code)
+		final Map<String, PropertyDescriptor> properties = new LinkedHashMap<>();
+
+		// Walk from subclass to superclass; subclass properties take precedence
+		Class<?> currentClass = beanClass;
+		while ( currentClass != null && currentClass != stopClass && currentClass != Object.class ) {
+			introspectClass( currentClass, properties );
+			currentClass = currentClass.getSuperclass();
+		}
+
+		final PropertyDescriptor[] descriptors = properties.values().toArray( new PropertyDescriptor[0] );
+		return new SimpleBeanInfo( descriptors );
+	}
 
+	/**
+	 * Simple implementation of {@link BeanInfo} that holds a fixed array of property descriptors.
+	 */
+	private static class SimpleBeanInfo implements BeanInfo {
+		private final PropertyDescriptor[] propertyDescriptors;
+
+		SimpleBeanInfo(PropertyDescriptor[] propertyDescriptors) {
+			this.propertyDescriptors = propertyDescriptors;
+		}
+
+		@Override
+		public PropertyDescriptor[] getPropertyDescriptors() {
+			return propertyDescriptors;
+		}
+	}
+
+	private static void introspectClass(final Class<?> clazz, final Map<String, PropertyDescriptor> properties) {
+		for ( final Method method : clazz.getDeclaredMethods() ) {
+			final int modifiers = method.getModifiers();
+			// Skip static, non-public, bridge, and synthetic methods
+			if ( Modifier.isStatic( modifiers )
+					|| !Modifier.isPublic( modifiers )
+					|| method.isBridge()
+					|| method.isSynthetic() ) {
+				continue;
+			}
+
+			final String methodName = method.getName();
+			final int paramCount = method.getParameterCount();
+			final Class<?> returnType = method.getReturnType();
+
+			// Check for getter: getXxx() or isXxx()
+			if ( paramCount == 0 && returnType != void.class ) {
+				String propertyName = null;
+				if ( methodName.startsWith( "get" ) && methodName.length() > 3 ) {
+					propertyName = decapitalize( methodName.substring( 3 ) );
+				}
+				else if ( methodName.startsWith( "is" ) && methodName.length() > 2
+						&& ( returnType == boolean.class || returnType == Boolean.class ) ) {
+					propertyName = decapitalize( methodName.substring( 2 ) );
+				}
+
+				if ( propertyName != null && !propertyName.isEmpty() ) {
+					final PropertyDescriptor existing = properties.get( propertyName );
+					if ( existing == null ) {
+						properties.put( propertyName, new PropertyDescriptor( propertyName, method, null ) );
+					}
+					else if ( existing.getReadMethod() == null ) {
+						// Merge: we had a setter, now add the getter
+						properties.put( propertyName,
+								new PropertyDescriptor( propertyName, method, existing.getWriteMethod() ) );
+					}
+					// else: subclass already defined a getter, keep it (subclass precedence)
+				}
+			}
+
+			// Check for setter: setXxx(value)
+			// Note: if overloaded setters exist, we take the first one found.
+			// This is acceptable for name-based property matching.
+			if ( paramCount == 1 && methodName.startsWith( "set" ) && methodName.length() > 3 ) {
+				final String propertyName = decapitalize( methodName.substring( 3 ) );
+				if ( !propertyName.isEmpty() ) {
+					final PropertyDescriptor existing = properties.get( propertyName );
+					if ( existing == null ) {
+						properties.put( propertyName, new PropertyDescriptor( propertyName, null, method ) );
+					}
+					else if ( existing.getWriteMethod() == null ) {
+						// Merge: we had a getter, now add the setter
+						properties.put( propertyName,
+								new PropertyDescriptor( propertyName, existing.getReadMethod(), method ) );
+					}
+					// else: subclass already defined a setter, keep it (subclass precedence)
+				}
+			}
+		}
+	}
 }

hibernate-core/src/main/java/org/hibernate/internal/util/beans/BeanIntrospectionException.java

@@ -7,7 +7,7 @@
 import org.hibernate.HibernateException;
 
 /**
- * Indicates a problem dealing with {@link java.beans.BeanInfo} via the {@link BeanInfoHelper} delegate.
+ * Indicates a problem dealing with {@link BeanInfo} via the {@link BeanInfoHelper} delegate.
  *
  * @author Steve Ebersole
  */

hibernate-core/src/main/java/org/hibernate/internal/util/beans/PropertyDescriptor.java

@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.internal.util.beans;
+
+import java.lang.reflect.Method;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Describes a single property of a JavaBean.
+ * This is a reimplementation to avoid dependency on the {@code java.desktop} module.
+ */
+public final class PropertyDescriptor {
+	private final String name;
+	private final @Nullable Method readMethod;
+	private final @Nullable Method writeMethod;
+
+	public PropertyDescriptor(final String name, final @Nullable Method readMethod, final @Nullable Method writeMethod) {
+		this.name = name;
+		this.readMethod = readMethod;
+		this.writeMethod = writeMethod;
+	}
+
+	/**
+	 * Gets the programmatic name of this property.
+	 */
+	public String getName() {
+		return name;
+	}
+
+	/**
+	 * Gets the method used to read the property value.
+	 *
+	 * @return The getter method, or null if the property is write-only.
+	 */
+	public @Nullable Method getReadMethod() {
+		return readMethod;
+	}
+
+	/**
+	 * Gets the method used to write the property value.
+	 *
+	 * @return The setter method, or null if the property is read-only.
+	 */
+	public @Nullable Method getWriteMethod() {
+		return writeMethod;
+	}
+}

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/internal/CompoundNaturalIdMapping.java

@@ -57,7 +57,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import static java.beans.Introspector.decapitalize;
+import static org.hibernate.internal.util.StringHelper.decapitalize;
 import static java.lang.reflect.Modifier.isStatic;
 import static java.util.Collections.emptyMap;