Consider filter configuration in AotMappingContext.

Closes #3474
Original pull request: #3475

Author: christophstrobl

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

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.aot;
 
+import java.io.File;
 import java.math.BigDecimal;
 import java.text.Format;
 import java.time.LocalDateTime;
@@ -35,18 +36,33 @@
 import org.springframework.data.mapping.model.EntityInstantiators;
 import org.springframework.data.mapping.model.Property;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
+import org.springframework.data.util.TypeCollector;
 
 /**
  * Simple {@link AbstractMappingContext} for processing of AOT contributions.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 4.0
  */
 class AotMappingContext extends
 		AbstractMappingContext<BasicPersistentEntity<?, AotMappingContext.AotPersistentProperty>, AotMappingContext.AotPersistentProperty> {
 
 	private final EntityInstantiators instantiators = new EntityInstantiators();
 	private final AotAccessorFactory propertyAccessorFactory = new AotAccessorFactory();
+	private final Predicate<Class<?>> typeCollectorFilter;
+
+	AotMappingContext() {
+		this(TypeCollector.typeFilter(typeCollector -> {}));
+	}
+
+	/**
+	 * @param typeFilter used for filtering during {@link #shouldCreatePersistentEntityFor(TypeInformation)}
+	 * @since 4.1
+	 */
+	AotMappingContext(Predicate<Class<?>> typeFilter) {
+		this.typeCollectorFilter = typeFilter;
+	}
 
 	/**
 	 * Contribute entity instantiators and property accessors for the given {@link PersistentEntity} that are captured
@@ -85,12 +101,17 @@ protected boolean shouldCreatePersistentEntityFor(TypeInformation<?> typeInforma
 				|| isInPackage.test(BigDecimal.class) // java.math
 				|| isInPackage.test(LocalDateTime.class) // java.time
 				|| isInPackage.test(Format.class) // java.text
+				|| isInPackage.test(File.class) // java.io
 				|| isInPackage.test(Point.class) // org.springframework.data.geo
 				|| isInPackage.test(Page.class) // org.springframework.data.domain
 				|| type.getPackageName().startsWith("javax")) {
 			return false;
 		}
 
+		if (!typeCollectorFilter.test(type)) {
+			return false;
+		}
+
 		return super.shouldCreatePersistentEntityFor(typeInformation);
 	}
 

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

@@ -82,7 +82,9 @@ public void setEnvironment(Environment environment) {
 			return null;
 		}
 
-		DefaultAotContext aotContext = new DefaultAotContext(registeredBean.getBeanFactory(), getConfiguredEnvironmentOrTryToResolveOne(registeredBean));
+		DefaultAotContext aotContext = new DefaultAotContext(registeredBean.getBeanFactory(),
+				getConfiguredEnvironmentOrTryToResolveOne(registeredBean),
+				new AotMappingContext(TypeCollector.typeFilter(typeCollectorCustomizer())));
 		return contribute(aotContext, resolveManagedTypes(registeredBean), registeredBean);
 	}
 

src/main/java/org/springframework/data/util/TypeCollector.java

@@ -126,6 +126,32 @@ public TypeCollector filterFields(Predicate<Field> filter) {
 		return this;
 	}
 
+	/**
+	 * Return the combined type filter used when collecting reachable types (SPI {@link TypeCollectorFilters} plus any
+	 * {@link #filterTypes(Predicate) filterTypes} predicates).
+	 *
+	 * @return the type filter; never {@literal null}.
+	 * @since 4.1
+	 */
+	public Predicate<Class<?>> getTypeFilter() {
+		return this.typeFilter;
+	}
+
+	/**
+	 * Build the combined type filter for the given configuration, matching the filter applied by
+	 * {@link #inspect(Consumer, Collection)} for the same customizer.
+	 *
+	 * @param customizer configures the collector; must not be {@literal null}.
+	 * @return the type filter; never {@literal null}.
+	 * @since 4.1
+	 */
+	public static Predicate<Class<?>> typeFilter(Consumer<TypeCollector> customizer) {
+
+		TypeCollector collector = new TypeCollector();
+		customizer.accept(collector);
+		return collector.getTypeFilter();
+	}
+
 	/**
 	 * Inspect the given type and resolve those reachable via fields, methods, generics, ...
 	 *

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

@@ -18,12 +18,14 @@
 import static org.assertj.core.api.Assertions.*;
 
 import java.util.BitSet;
+import java.util.function.Predicate;
 
 import org.junit.jupiter.api.Test;
 
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.Reference;
 import org.springframework.data.core.TypeInformation;
+import org.springframework.data.util.TypeCollector;
 
 /**
  * Unit tests for {@link AotMappingContext}.
@@ -62,6 +64,17 @@ void doesNotContributeGeneratedAccessorForUnsupportedType() {
 		});
 	}
 
+	@Test // GH-3474
+	void doesNotCreateEntityWhenTypeCollectorFilterExcludesNestedType() {
+
+		Predicate<Class<?>> filter = TypeCollector
+				.typeFilter(c -> c.filterTypes(cls -> cls != ExcludedByFilterNested.class));
+		AotMappingContext filteredContext = new AotMappingContext(filter);
+
+		assertThat(filteredContext.getPersistentEntity(EntityWithFilteredNested.class)).isNotNull();
+		assertThat(filteredContext.getPersistentEntity(ExcludedByFilterNested.class)).isNull();
+	}
+
 	static class DemoEntity {
 
 		@Id String id;
@@ -112,4 +125,15 @@ public void setName(String name) {
 		}
 	}
 
+	static class ExcludedByFilterNested {
+
+		String value;
+	}
+
+	static class EntityWithFilteredNested {
+
+		@Id String id;
+		ExcludedByFilterNested nested;
+	}
+
 }

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

@@ -15,10 +15,22 @@
  */
 package org.springframework.data.aot;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.function.Predicate;
 
 import org.junit.jupiter.api.Test;
-import org.springframework.data.aot.types.*;
+import org.springframework.data.aot.types.AbstractType;
+import org.springframework.data.aot.types.CyclicGenerics;
+import org.springframework.data.aot.types.CyclicPropertiesA;
+import org.springframework.data.aot.types.CyclicPropertiesB;
+import org.springframework.data.aot.types.CyclicPropertiesSelf;
+import org.springframework.data.aot.types.EmptyType1;
+import org.springframework.data.aot.types.EmptyType2;
+import org.springframework.data.aot.types.FieldsAndMethods;
+import org.springframework.data.aot.types.InterfaceType;
+import org.springframework.data.aot.types.TypesInMethodSignatures;
+import org.springframework.data.aot.types.WithDeclaredClass;
 import org.springframework.data.util.TypeCollector;
 
 /**
@@ -77,4 +89,23 @@ void appliesFilterPredicate() {
 				.list()).containsOnly(TypesInMethodSignatures.class, EmptyType1.class);
 	}
 
+	@Test // GH-3474
+	void typeFilterStaticMatchesInspectWithSameCustomizer() {
+
+		Predicate<Class<?>> fromStatic = TypeCollector.typeFilter(tc -> {});
+		TypeCollector collector = new TypeCollector();
+
+		assertThat(fromStatic.test(FieldsAndMethods.class))
+				.isEqualTo(collector.getTypeFilter().test(FieldsAndMethods.class));
+	}
+
+	@Test // GH-3474
+	void typeFilterReflectsAdditionalTypeFilters() {
+
+		Predicate<Class<?>> filter = TypeCollector.typeFilter(c -> c.filterTypes(cls -> false));
+
+		assertThat(filter.test(FieldsAndMethods.class)).isFalse();
+		assertThat(TypeCollector.inspect(c -> c.filterTypes(cls -> false), FieldsAndMethods.class).list()).isEmpty();
+	}
+
 }