Refine exclusions for AOT processing.

Throw MappingException referring to the entity type for easier debugging of the property creation chain.

Add exclusion for properties starting with $$_ (synthetic Hibernate fields). Exclude java.util and javax types from AOT entity processing as well as arrays.

See #2595
Original Pull Request: #3318

Author: mp911de

src/main/java/org/springframework/data/aot/AotMappingContext.java

@@ -15,10 +15,14 @@
  */
 package org.springframework.data.aot;
 
-import java.lang.reflect.InaccessibleObjectException;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import java.math.BigDecimal;
+import java.text.Format;
+import java.time.LocalDateTime;
+import java.util.UUID;
+import java.util.function.Predicate;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.geo.Point;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.context.AbstractMappingContext;
@@ -41,8 +45,6 @@
 class AotMappingContext extends
 		AbstractMappingContext<BasicPersistentEntity<?, AotMappingContext.AotPersistentProperty>, AotMappingContext.AotPersistentProperty> {
 
-	private static final Log logger = LogFactory.getLog(AotMappingContext.class);
-
 	private final EntityInstantiators instantiators = new EntityInstantiators();
 	private final AotAccessorFactory propertyAccessorFactory = new AotAccessorFactory();
 
@@ -55,25 +57,43 @@ class AotMappingContext extends
 	 */
 	public void contribute(Class<?> entityType) {
 
-		try {
-			BasicPersistentEntity<?, AotPersistentProperty> entity = getPersistentEntity(entityType);
-
-			if (entity != null && !entity.getType().isArray()) {
+		BasicPersistentEntity<?, AotPersistentProperty> entity = getPersistentEntity(entityType);
 
-				EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
-				if (instantiator instanceof EntityInstantiatorSource source) {
-					source.getInstantiatorFor(entity);
-				}
+		if (entity != null) {
 
-				propertyAccessorFactory.initialize(entity);
-			}
-		} catch (InaccessibleObjectException exception) {
-			if(logger.isInfoEnabled()) {
-				logger.info("Unable to contribute bytecode accessor for [%s]".formatted(entityType), exception);
+			EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
+			if (instantiator instanceof EntityInstantiatorSource source) {
+				source.getInstantiatorFor(entity);
 			}
+
+			propertyAccessorFactory.initialize(entity);
 		}
 	}
 
+	@Override
+	protected boolean shouldCreatePersistentEntityFor(TypeInformation<?> typeInformation) {
+
+		Class<?> type = typeInformation.getType();
+
+		if (type.isArray() || type.isPrimitive() || type.isEnum()) {
+			return false;
+		}
+
+		Predicate<Class<?>> isInPackage = packageMember -> type.getPackageName().startsWith(packageMember.getPackageName());
+
+		if (isInPackage.test(UUID.class) // java.util
+				|| isInPackage.test(BigDecimal.class) // java.math
+				|| isInPackage.test(LocalDateTime.class) // java.time
+				|| isInPackage.test(Format.class) // java.text
+				|| isInPackage.test(Point.class) // org.springframework.data.geo
+				|| isInPackage.test(Page.class) // org.springframework.data.domain
+				|| type.getPackageName().startsWith("javax")) {
+			return false;
+		}
+
+		return super.shouldCreatePersistentEntityFor(typeInformation);
+	}
+
 	@Override
 	protected <T> BasicPersistentEntity<?, AotPersistentProperty> createPersistentEntity(
 			TypeInformation<T> typeInformation) {

src/main/java/org/springframework/data/aot/AotTypeConfiguration.java

@@ -35,15 +35,15 @@
  * cglib bytecode generation and other common tasks.
  * <p>
  * On {@link #contribute(Environment, GenerationContext)} the configuration is added to the {@link GenerationContext}.
- * 
+ *
  * @author Christoph Strobl
  * @since 4.0
  */
 public interface AotTypeConfiguration {
 
 	/**
 	 * Configure the referenced type for data binding. In case of {@link java.lang.annotation.Annotation} only data ones
-	 * are considered. For more fine grained control use {@link #forReflectiveAccess(MemberCategory...)}.
+	 * are considered. For more fine-grained control use {@link #forReflectiveAccess(MemberCategory...)}.
 	 *
 	 * @return this.
 	 */
@@ -71,7 +71,7 @@ public interface AotTypeConfiguration {
 	 * Configure the referenced type as a projection interface returned by eg. a query method.
 	 * <p>
 	 * Shortcut for {@link #proxyInterface(Class[]) proxyInterface(TargetAware, SpringProxy, DecoratingProxy)}
-	 * 
+	 *
 	 * @return this.
 	 */
 	default AotTypeConfiguration usedAsProjectionInterface() {
@@ -111,7 +111,7 @@ default AotTypeConfiguration repositoryProxy() {
 
 	/**
 	 * Register a proxy for the referenced type that also implements the given proxyInterfaces.
-	 * 
+	 *
 	 * @param proxyInterfaces additional interfaces the proxy implements. Order matters!
 	 * @return this.
 	 */
@@ -129,14 +129,14 @@ default AotTypeConfiguration proxyInterface(Class<?>... proxyInterfaces) {
 
 	/**
 	 * Configure the referenced type for usage with Querydsl by registering hints for potential {@code Q} types.
-	 * 
+	 *
 	 * @return this.
 	 */
 	AotTypeConfiguration forQuerydsl();
 
 	/**
 	 * Write the configuration to the given {@link GenerationContext}.
-	 * 
+	 *
 	 * @param environment must not be {@literal null}.
 	 * @param generationContext must not be {@literal null}.
 	 */

src/main/java/org/springframework/data/aot/DefaultAotContext.java

@@ -35,6 +35,7 @@
 import org.springframework.aot.hint.TypeReference;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.aot.AotProcessingException;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
@@ -229,6 +230,16 @@ public AotTypeConfiguration forQuerydsl() {
 		@Override
 		public void contribute(Environment environment, GenerationContext generationContext) {
 
+			try {
+				doContribute(environment, generationContext);
+			} catch (RuntimeException e) {
+				throw new AotProcessingException("Cannot contribute Ahead-of-Time optimizations for '" + type.getName() + "'",
+						e);
+			}
+		}
+
+		private void doContribute(Environment environment, GenerationContext generationContext) {
+
 			if (!this.categories.isEmpty()) {
 				generationContext.getRuntimeHints().reflection().registerType(this.type,
 						categories.toArray(MemberCategory[]::new));

src/main/java/org/springframework/data/mapping/context/AbstractMappingContext.java

@@ -424,8 +424,9 @@ protected Optional<E> addPersistentEntity(TypeInformation<?> typeInformation) {
 
 			entity = doAddPersistentEntity(typeInformation);
 
-		} catch (BeansException e) {
-			throw new MappingException(e.getMessage(), e);
+		} catch (RuntimeException e) {
+			throw new MappingException(
+					"Cannot create PersistentEntity for '%s'".formatted(typeInformation.getType().getName()), e);
 		} finally {
 			write.unlock();
 		}
@@ -763,17 +764,18 @@ enum PersistentPropertyFilter implements FieldFilter {
 
 		INSTANCE;
 
-		private static final Streamable<PropertyMatch> UNMAPPED_PROPERTIES;
+		private static final Collection<PropertyMatch> UNMAPPED_PROPERTIES;
 
 		static {
 
 			Set<PropertyMatch> matches = new HashSet<>();
 			matches.add(new PropertyMatch("class", null));
 			matches.add(new PropertyMatch("this\\$.*", null));
+			matches.add(new PropertyMatch("\\$\\$_.*", null));
 			matches.add(new PropertyMatch("metaClass", "groovy.lang.MetaClass"));
 			matches.add(new KotlinDataClassPropertyMatch(".*\\$delegate", null));
 
-			UNMAPPED_PROPERTIES = Streamable.of(matches);
+			UNMAPPED_PROPERTIES = matches;
 		}
 
 		@Override
@@ -783,8 +785,13 @@ public boolean matches(Field field) {
 				return false;
 			}
 
-			return UNMAPPED_PROPERTIES.stream()//
-					.noneMatch(it -> it.matches(field));
+			for (PropertyMatch property : UNMAPPED_PROPERTIES) {
+				if (property.matches(field)) {
+					return false;
+				}
+			}
+
+			return true;
 		}
 
 		/**

src/test/java/org/springframework/data/aot/AotMappingContextUnitTests.java

@@ -15,19 +15,43 @@
  */
 package org.springframework.data.aot;
 
+import static org.assertj.core.api.Assertions.*;
+
+import java.util.BitSet;
+
 import org.junit.jupiter.api.Test;
+
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.Reference;
 import org.springframework.data.util.TypeInformation;
 
 /**
+ * Unit tests for {@link AotMappingContext}.
+ *
  * @author Christoph Strobl
+ * @author Mark Paluch
  */
 public class AotMappingContextUnitTests {
 
+	AotMappingContext context = new AotMappingContext();
+
 	@Test // GH-2595
 	void obtainEntityWithReference() {
-		new AotMappingContext().getPersistentEntity(TypeInformation.of(DemoEntity.class));
+		context.getPersistentEntity(TypeInformation.of(DemoEntity.class));
+	}
+
+	@Test // GH-2595
+	void doesNotCreateEntityForBitSet() {
+
+		assertThat(context.getPersistentEntity(EntityWithBitSet.class)).isNotNull();
+		assertThat(context.getPersistentEntity(BitSet.class)).isNull();
+	}
+
+	@Test // GH-2595
+	void doesNotCreateEntityForJavaxReference() {
+
+		assertThat(context.getPersistentEntity(EntityWithReference.class)).isNotNull();
+		assertThat(context.getPersistentEntity(javax.naming.Reference.class)).isNull();
 	}
 
 	static class DemoEntity {
@@ -41,4 +65,17 @@ static class DemoEntity {
 	static class ReferencedEntity {
 		@Id String id;
 	}
+
+	static class EntityWithBitSet {
+
+		@Id String id;
+		BitSet bitset;
+	}
+
+	static class EntityWithReference {
+
+		@Id String id;
+		javax.naming.Reference reference;
+	}
+
 }

src/test/java/org/springframework/data/mapping/context/AbstractMappingContextUnitTests.java

@@ -118,6 +118,18 @@ void doesNotCreatePersistentPropertyForGroovyMetaClass() {
 		assertThat(entity.getPersistentProperty("metaClass")).isNull();
 	}
 
+	@Test // GH-2595
+	void doesNotCreatePersistentPropertyHibernateBytecodeEnhancements() {
+
+		var mappingContext = new SampleMappingContext();
+		mappingContext.initialize();
+
+		PersistentEntity<Object, SamplePersistentProperty> entity = mappingContext
+				.getRequiredPersistentEntity(Sample.class);
+		assertThat(entity.getPersistentProperty("$$_hibernate")).isNull();
+		assertThat(mappingContext.hasPersistentEntityFor(Excluded.class)).isFalse();
+	}
+
 	@Test // DATACMNS-332
 	void usesMostConcreteProperty() {
 
@@ -401,10 +413,15 @@ private class Unsupported {
 	class Sample {
 
 		MetaClass metaClass;
+		Excluded $$_hibernate;
 		List<Person> persons;
 		TreeMap<String, Person> personMap;
 	}
 
+	class Excluded {
+
+	}
+
 	static class Base {
 		String foo;
 	}