Support for association target type detection for jMolecules.

We now detect the component type of jMolecules' Association as association target type in AbstractPersistentProperty. AnnotationBasedPersistentProperty keeps the lookup of the explicit @reference around but falls back to the Association analysis for that.

@reference is now only considered by AnnotationBasedPersistentProperty. It was previously also (erroneously) considered by AbstractPersistentProperty.

It was also changed to return `null` in case no association target type could be looked up instead of returning the sole property's type in case that is an entity. This was done to satisfy the behavior documented on the interface but also to avoid the call to isEntity() during the calculation which might use association information in turn and thus lead to a stack overflow. Reworded the contract of PersistentProperty.getAssociationTargetType() to emphasize the symmetry with ….isAssociation() in implementation classes.

Closes: #2344.

Author: odrotbohm

src/main/java/org/springframework/data/mapping/PersistentProperty.java

@@ -383,11 +383,13 @@ default boolean hasActualTypeAnnotation(Class<? extends Annotation> annotationTy
 	}
 
 	/**
-	 * Return the type the property refers to in case it's an association.
+	 * Return the type the property refers to in case it's an association, i.e. {@link #isAssociation()} returns
+	 * {@literal true}. That means, that implementations <em>must</em> return a non-{@literal null} value from this method
+	 * in that case. We also recommend to return {@literal null} for non-associations right away to establish symmetry
+	 * between this method and {@link #isAssociation()}.
 	 *
-	 * @return the type the property refers to in case it's an association or {@literal null} in case it's not an
-	 *         association, the target entity type is not explicitly defined (either explicitly or through the property
-	 *         type itself).
+	 * @return the type the property refers to in case it's an association, i.e. {@link #isAssociation()} returns
+	 *         {@literal true}.
 	 * @since 2.1
 	 */
 	@Nullable

src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java

@@ -22,7 +22,6 @@
 import java.util.Map;
 import java.util.Optional;
 
-import org.springframework.data.annotation.Reference;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PersistentProperty;
@@ -64,6 +63,9 @@ public abstract class AbstractPersistentProperty<P extends PersistentProperty<P>
 	private final Lazy<Boolean> usePropertyAccess;
 	private final Lazy<Optional<? extends TypeInformation<?>>> entityTypeInformation;
 
+	private final Lazy<Boolean> isAssociation;
+	private final Lazy<Class<?>> associationTargetType;
+
 	private final Method getter;
 	private final Method setter;
 	private final Field field;
@@ -86,6 +88,15 @@ public AbstractPersistentProperty(Property property, PersistentEntity<?, P> owne
 		this.hashCode = Lazy.of(property::hashCode);
 		this.usePropertyAccess = Lazy.of(() -> owner.getType().isInterface() || CAUSE_FIELD.equals(getField()));
 
+		this.isAssociation = Lazy.of(() -> ASSOCIATION_TYPE != null && ASSOCIATION_TYPE.isAssignableFrom(rawType));
+		this.associationTargetType = ASSOCIATION_TYPE == null
+				? Lazy.empty()
+				: Lazy.of(() -> Optional.of(getTypeInformation())
+						.map(it -> it.getSuperTypeInformation(ASSOCIATION_TYPE))
+						.map(TypeInformation::getComponentType)
+						.map(TypeInformation::getType)
+						.orElse(null));
+
 		this.entityTypeInformation = Lazy.of(() -> Optional.ofNullable(information.getActualType())//
 				.filter(it -> !simpleTypeHolder.isSimpleType(it.getType()))//
 				.filter(it -> !it.isCollectionLike())//
@@ -170,6 +181,7 @@ public Iterable<? extends TypeInformation<?>> getPersistentEntityTypes() {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.PersistentProperty#getGetter()
 	 */
+	@Nullable
 	@Override
 	public Method getGetter() {
 		return this.getter;
@@ -179,6 +191,7 @@ public Method getGetter() {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.PersistentProperty#getSetter()
 	 */
+	@Nullable
 	@Override
 	public Method getSetter() {
 		return this.setter;
@@ -188,6 +201,7 @@ public Method getSetter() {
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.PersistentProperty#getWither()
 	 */
+	@Nullable
 	@Override
 	public Method getWither() {
 		return this.wither;
@@ -245,8 +259,7 @@ public boolean isImmutable() {
 	 */
 	@Override
 	public boolean isAssociation() {
-		return isAnnotationPresent(Reference.class) //
-				|| ASSOCIATION_TYPE != null && ASSOCIATION_TYPE.isAssignableFrom(rawType);
+		return isAssociation.get();
 	}
 
 	/*
@@ -259,6 +272,16 @@ public Association<P> getAssociation() {
 		return association.orElse(null);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.PersistentProperty#getAssociationTargetType()
+	 */
+	@Nullable
+	@Override
+	public Class<?> getAssociationTargetType() {
+		return associationTargetType.getNullable();
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.PersistentProperty#isCollectionLike()

src/main/java/org/springframework/data/mapping/model/AnnotationBasedPersistentProperty.java

@@ -74,6 +74,18 @@ public abstract class AnnotationBasedPersistentProperty<P extends PersistentProp
 			&& (isAnnotationPresent(Reference.class) || super.isAssociation()));
 	private final Lazy<Boolean> isId = Lazy.of(() -> isAnnotationPresent(Id.class));
 	private final Lazy<Boolean> isVersion = Lazy.of(() -> isAnnotationPresent(Version.class));
+	private final Lazy<Class<?>> associationTargetType = Lazy.of(() -> {
+
+		if (!isAssociation()) {
+			return null;
+		}
+
+		return Optional.of(Reference.class) //
+				.map(this::findAnnotation) //
+				.map(Reference::to) //
+				.map(it -> !Class.class.equals(it) ? it : getActualType()) //
+				.orElseGet(() -> super.getAssociationTargetType());
+	});
 
 	/**
 	 * Creates a new {@link AnnotationBasedPersistentProperty}.
@@ -285,18 +297,7 @@ public boolean usePropertyAccess() {
 	@Nullable
 	@Override
 	public Class<?> getAssociationTargetType() {
-
-		Reference reference = findAnnotation(Reference.class);
-
-		if (reference == null) {
-			return isEntity() ? getActualType() : null;
-		}
-
-		Class<?> targetType = reference.to();
-
-		return Class.class.equals(targetType) //
-				? isEntity() ? getActualType() : null //
-				: targetType;
+		return associationTargetType.getNullable();
 	}
 
 	/*

src/test/java/org/springframework/data/mapping/model/AbstractPersistentPropertyUnitTests.java

@@ -32,6 +32,8 @@
 import java.util.TreeMap;
 import java.util.TreeSet;
 
+import org.jmolecules.ddd.types.AggregateRoot;
+import org.jmolecules.ddd.types.Identifier;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.data.mapping.Association;
@@ -230,6 +232,7 @@ void detectsJMoleculesAssociation() {
 		SamplePersistentProperty property = getProperty(JMolecules.class, "association");
 
 		assertThat(property.isAssociation()).isTrue();
+		assertThat(property.getAssociationTargetType()).isEqualTo(JMoleculesAggregate.class);
 	}
 
 	private <T> BasicPersistentEntity<T, SamplePersistentProperty> getEntity(Class<T> type) {
@@ -371,11 +374,6 @@ public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
 		public <A extends Annotation> A findPropertyOrOwnerAnnotation(Class<A> annotationType) {
 			return null;
 		}
-
-		@Override
-		public Class<?> getAssociationTargetType() {
-			return null;
-		}
 	}
 
 	static class Sample {
@@ -392,6 +390,10 @@ class TreeMapWrapper {
 	}
 
 	class JMolecules {
-		org.jmolecules.ddd.types.Association association;
+		org.jmolecules.ddd.types.Association<JMoleculesAggregate, Identifier> association;
+	}
+
+	interface JMoleculesAggregate extends AggregateRoot<JMoleculesAggregate, Identifier> {
+
 	}
 }

src/test/java/org/springframework/data/mapping/model/AnnotationBasedPersistentPropertyUnitTests.java

@@ -24,11 +24,17 @@
 import java.lang.annotation.Target;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.stream.Stream;
 
+import org.assertj.core.api.ClassAssert;
+import org.jmolecules.ddd.types.AggregateRoot;
 import org.jmolecules.ddd.types.Association;
+import org.jmolecules.ddd.types.Identifier;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.springframework.core.annotation.AliasFor;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.data.annotation.AccessType;
@@ -242,12 +248,21 @@ public void getRequiredAnnotationThrowsException() {
 		assertThatThrownBy(() -> property.getRequiredAnnotation(Transient.class)).isInstanceOf(IllegalStateException.class);
 	}
 
-	@Test // DATACMNS-1318
-	public void detectsUltimateAssociationTargetClass() {
+	@TestFactory // DATACMNS-1318
+	public Stream<DynamicTest> detectsUltimateAssociationTargetClass() {
 
-		Stream.of("toSample", "toSample2", "sample", "withoutAnnotation").forEach(it -> {
-			assertThat(getProperty(WithReferences.class, it).getAssociationTargetType()).isEqualTo(Sample.class);
-		});
+		Function<String, ClassAssert> verifier = it -> assertThat(
+				getProperty(WithReferences.class, it).getAssociationTargetType());
+
+		Stream<DynamicTest> positives = DynamicTest.stream(Stream.of("toSample", "toSample2", "sample"), //
+				it -> String.format("Property %s resolves to %s.", it, Sample.class.getSimpleName()), //
+				it -> verifier.apply(it).isEqualTo(Sample.class));
+
+		Stream<DynamicTest> negatives = DynamicTest.stream(Stream.of("withoutAnnotation"), //
+				it -> String.format("Property %s resolves to null.", it), //
+				it -> verifier.apply(it).isNull());
+
+		return Stream.concat(positives, negatives);
 	}
 
 	@Test // DATACMNS-1359
@@ -295,8 +310,12 @@ public void missingRequiredFieldThrowsException() {
 	}
 
 	@Test // GH-2315
-	void detectesJMoleculesAssociation() {
-		assertThat(getProperty(JMolecules.class, "association").isAssociation()).isTrue();
+	void detectsJMoleculesAssociation() {
+
+		SamplePersistentProperty property = getProperty(JMolecules.class, "association");
+
+		assertThat(property.isAssociation()).isTrue();
+		assertThat(property.getAssociationTargetType()).isEqualTo(JMoleculesAggregate.class);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -484,6 +503,8 @@ interface NoField {
 	}
 
 	static class JMolecules {
-		Association association;
+		Association<JMoleculesAggregate, Identifier> association;
 	}
+
+	interface JMoleculesAggregate extends AggregateRoot<JMoleculesAggregate, Identifier> {}
 }