GH-2420 - Simplify nested projection code.

Author: meistermeier

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

@@ -15,19 +15,14 @@
  */
 package org.springframework.data.mapping.context;
 
-import org.springframework.data.mapping.PersistentEntity;
-import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.projection.ProjectionInformation;
-import org.springframework.data.util.TypeInformation;
 
 import java.beans.PropertyDescriptor;
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Predicate;
 
 /**
@@ -36,10 +31,10 @@
  */
 public class PropertyFilterSupport {
 
-	public static List<PropertyPath> addPropertiesFrom(Class<?> returnType, Class<?> domainType,
-													   ProjectionFactory projectionFactory,
-													   Predicate<Class<?>> simpleTypePredicate,  // TODO SimpleTypeHolder or CustomConversions
-													   MappingContext<?, ?> mappingContext) {
+	public static Map<PropertyPath, Boolean> addPropertiesFrom(Class<?> returnType, Class<?> domainType,
+															   ProjectionFactory projectionFactory,
+															   Predicate<Class<?>> simpleTypePredicate,  // TODO SimpleTypeHolder or CustomConversions
+															   MappingContext<?, ?> mappingContext) {
 
 		ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(returnType);
 
@@ -49,11 +44,11 @@ public static List<PropertyPath> addPropertiesFrom(Class<?> returnType, Class<?>
 
 		if (openProjection || typeFromHierarchy) {
 			// *Mark wants to do something with object checks here
-			return Collections.emptyList();
+			return Collections.emptyMap();
 		}
 		// if ^^ false -> DTO / interface projection
 
-		List<PropertyPath> propertyPaths = new ArrayList<>();
+		Map<PropertyPath, Boolean> propertyPaths = new ConcurrentHashMap<>();
 		for (PropertyDescriptor inputProperty : projectionInformation.getInputProperties()) {
 			addPropertiesFrom(returnType, domainType, projectionFactory, simpleTypePredicate, propertyPaths, inputProperty.getName(), mappingContext);
 		}
@@ -62,7 +57,7 @@ public static List<PropertyPath> addPropertiesFrom(Class<?> returnType, Class<?>
 
 	private static void addPropertiesFrom(Class<?> returnedType, Class<?> domainType, ProjectionFactory factory,
 										  Predicate<Class<?>> simpleTypePredicate,
-										  Collection<PropertyPath> filteredProperties, String inputProperty,
+										  Map<PropertyPath, Boolean> filteredProperties, String inputProperty,
 										  MappingContext<?, ?> mappingContext) {
 
 		ProjectionInformation projectionInformation = factory.getProjectionInformation(returnedType);
@@ -82,104 +77,30 @@ private static void addPropertiesFrom(Class<?> returnedType, Class<?> domainType
 		// 2. Something that looks like an entity needs to get processed as such
 		// 3. Embedded projection
 		if (simpleTypePredicate.test(propertyType)) {
-			filteredProperties.add(propertyPath);
+			filteredProperties.put(propertyPath, false);
 		} else if (mappingContext.hasPersistentEntityFor(propertyType)) {
-			// avoid recursion / cycles
-			if (propertyType.equals(domainType)) {
-				return;
-			}
-			processEntity(propertyPath, filteredProperties, simpleTypePredicate, mappingContext);
-
+			filteredProperties.put(propertyPath, true);
 		} else {
 			ProjectionInformation nestedProjectionInformation = factory.getProjectionInformation(propertyType);
-			filteredProperties.add(propertyPath);
 			// Closed projection should get handled as above (recursion)
 			if (nestedProjectionInformation.isClosed()) {
+				filteredProperties.put(propertyPath, false);
 				for (PropertyDescriptor nestedInputProperty : nestedProjectionInformation.getInputProperties()) {
 					PropertyPath nestedPropertyPath = propertyPath.nested(nestedInputProperty.getName());
-					filteredProperties.add(nestedPropertyPath);
+
+					if (propertyPath.hasNext() && (domainType.equals(propertyPath.getLeafProperty().getOwningType().getType())
+							|| returnedType.equals(propertyPath.getLeafProperty().getOwningType().getType()))) {
+						break;
+					}
 					addPropertiesFrom(domainType, returnedType, factory, simpleTypePredicate, filteredProperties,
 							nestedPropertyPath.toDotPath(), mappingContext);
 				}
 			} else {
 				// an open projection at this place needs to get replaced with the matching (real) entity
 				PropertyPath domainTypeBasedPropertyPath = PropertyPath.from(propertyPath.toDotPath(), domainType);
-				processEntity(domainTypeBasedPropertyPath, filteredProperties, simpleTypePredicate, mappingContext);
+				filteredProperties.put(domainTypeBasedPropertyPath, true);
 			}
 		}
 	}
 
-	private static void processEntity(PropertyPath propertyPath, Collection<PropertyPath> filteredProperties,
-									  Predicate<Class<?>> simpleTypePredicate,
-									  MappingContext<?, ?> mappingContext) {
-
-		PropertyPath leafProperty = propertyPath.getLeafProperty();
-		TypeInformation<?> propertyParentType = leafProperty.getOwningType();
-		String inputProperty = leafProperty.getSegment();
-
-		PersistentEntity<?, ?> persistentEntity = mappingContext.getPersistentEntity(propertyParentType);
-		PersistentProperty<?> persistentProperty = persistentEntity.getPersistentProperty(inputProperty);
-		Class<?> propertyEntityType = persistentProperty.getActualType();
-
-		// Use domain type as root type for the property path
-		addPropertiesFromEntity(filteredProperties, propertyPath, simpleTypePredicate, propertyEntityType, mappingContext, new HashSet<>());
-	}
-
-	private static void addPropertiesFromEntity(Collection<PropertyPath> filteredProperties, PropertyPath propertyPath,
-												Predicate<Class<?>> simpleTypePredicate,
-												Class<?> propertyType, MappingContext<?, ?> mappingContext,
-												Collection<PersistentEntity<?, ?>> processedEntities) {
-
-		PersistentEntity<?, ?> persistentEntityFromProperty = mappingContext.getPersistentEntity(propertyType);
-		// break the recursion / cycles
-		if (hasProcessedEntity(persistentEntityFromProperty, processedEntities)) {
-			return;
-		}
-		processedEntities.add(persistentEntityFromProperty);
-
-		// save base/root entity/projection type to avoid recursion later
-		Class<?> pathRootType = propertyPath.getOwningType().getType();
-		if (mappingContext.hasPersistentEntityFor(pathRootType)) {
-			processedEntities.add(mappingContext.getPersistentEntity(pathRootType));
-		}
-
-		takeAllPropertiesFromEntity(filteredProperties, simpleTypePredicate, propertyPath, mappingContext, persistentEntityFromProperty, processedEntities);
-	}
-
-	private static boolean hasProcessedEntity(PersistentEntity<?, ?> persistentEntityFromProperty,
-											  Collection<PersistentEntity<?, ?>> processedEntities) {
-
-		return processedEntities.contains(persistentEntityFromProperty);
-	}
-
-	private static void takeAllPropertiesFromEntity(Collection<PropertyPath> filteredProperties,
-													Predicate<Class<?>> simpleTypePredicate, PropertyPath propertyPath,
-													MappingContext<?, ?> mappingContext,
-													PersistentEntity<?, ?> persistentEntityFromProperty,
-													Collection<PersistentEntity<?, ?>> processedEntities) {
-
-		filteredProperties.add(propertyPath);
-
-		persistentEntityFromProperty.doWithAll(persistentProperty -> {
-			addPropertiesFromEntity(filteredProperties, propertyPath.nested(persistentProperty.getName()), simpleTypePredicate, mappingContext, processedEntities);
-		});
-	}
-
-	private static void addPropertiesFromEntity(Collection<PropertyPath> filteredProperties, PropertyPath propertyPath,
-												Predicate<Class<?>> simpleTypePredicate, MappingContext<?, ?> mappingContext,
-										  		Collection<PersistentEntity<?, ?>> processedEntities) {
-
-		// break the recursion / cycles
-		if (filteredProperties.contains(propertyPath)) {
-			return;
-		}
-		Class<?> propertyType = propertyPath.getLeafType();
-		// simple types can get added directly to the list.
-		if (simpleTypePredicate.test(propertyType)) {
-			filteredProperties.add(propertyPath);
-		// Other types are handled also as entities because there cannot be any nested projection within a real entity.
-		} else if (mappingContext.hasPersistentEntityFor(propertyType)) {
-			addPropertiesFromEntity(filteredProperties, propertyPath, simpleTypePredicate, propertyType, mappingContext, processedEntities);
-		}
-	}
 }