Revise KeySpaceResolver support to primary KeySpace detector source.

A configured KeySpaceResolver is now used primarily to detect the KeySpace to allow further customization of the KeySpace detection strategy.

The concept of a fallback resolver is now deprecated.

Closes #461

Author: mp911de

src/main/java/org/springframework/data/keyvalue/core/mapping/BasicKeyValuePersistentEntity.java

@@ -25,7 +25,7 @@
 import org.springframework.util.StringUtils;
 
 /**
- * {@link KeyValuePersistentEntity} implementation that adds specific meta-data such as the {@literal keySpace}..
+ * {@link KeyValuePersistentEntity} implementation that adds specific meta-data such as the {@literal keySpace}.
  *
  * @author Christoph Strobl
  * @author Oliver Gierke
@@ -37,31 +37,47 @@ public class BasicKeyValuePersistentEntity<T, P extends KeyValuePersistentProper
 
 	private static final SpelExpressionParser PARSER = new SpelExpressionParser();
 
-	private static final KeySpaceResolver DEFAULT_FALLBACK_RESOLVER = ClassNameKeySpaceResolver.INSTANCE;
-
 	private final @Nullable Expression keyspaceExpression;
 	private final @Nullable String keyspace;
 
 	/**
 	 * @param information must not be {@literal null}.
-	 * @param fallbackKeySpaceResolver can be {@literal null}.
+	 * @since 3.1
 	 */
-	public BasicKeyValuePersistentEntity(TypeInformation<T> information,
-			@Nullable KeySpaceResolver fallbackKeySpaceResolver) {
+	public BasicKeyValuePersistentEntity(TypeInformation<T> information) {
+		this(information, (String) null);
+	}
 
-		super(information);
+	/**
+	 * @param information must not be {@literal null}.
+	 * @param keySpaceResolver can be {@literal null}.
+	 */
+	public BasicKeyValuePersistentEntity(TypeInformation<T> information, @Nullable KeySpaceResolver keySpaceResolver) {
+		this(information, keySpaceResolver != null ? keySpaceResolver.resolveKeySpace(information.getType()) : null);
+	}
 
-		Class<T> type = information.getType();
-		String keySpace = AnnotationBasedKeySpaceResolver.INSTANCE.resolveKeySpace(type);
+	private BasicKeyValuePersistentEntity(TypeInformation<T> information, @Nullable String keyspace) {
 
-		if (StringUtils.hasText(keySpace)) {
+		super(information);
 
-			this.keyspace = keySpace;
-			this.keyspaceExpression = detectExpression(keySpace);
-		} else {
+		if (StringUtils.hasText(keyspace)) {
 
-			this.keyspace = resolveKeyspace(fallbackKeySpaceResolver, type);
+			this.keyspace = keyspace;
 			this.keyspaceExpression = null;
+		} else {
+
+			Class<T> type = information.getType();
+			String detectedKeyspace = AnnotationBasedKeySpaceResolver.INSTANCE.resolveKeySpace(type);
+
+			if (StringUtils.hasText(detectedKeyspace)) {
+
+				this.keyspace = detectedKeyspace;
+				this.keyspaceExpression = detectExpression(detectedKeyspace);
+			} else {
+
+				this.keyspace = ClassNameKeySpaceResolver.INSTANCE.resolveKeySpace(type);
+				this.keyspaceExpression = null;
+			}
 		}
 	}
 
@@ -79,12 +95,6 @@ private static Expression detectExpression(String potentialExpression) {
 		return expression instanceof LiteralExpression ? null : expression;
 	}
 
-	@Nullable
-	private static String resolveKeyspace(@Nullable KeySpaceResolver fallbackKeySpaceResolver, Class<?> type) {
-		return (fallbackKeySpaceResolver == null ? DEFAULT_FALLBACK_RESOLVER : fallbackKeySpaceResolver)
-				.resolveKeySpace(type);
-	}
-
 	@Override
 	public String getKeySpace() {
 		return keyspaceExpression == null //

src/main/java/org/springframework/data/keyvalue/core/mapping/ClassNameKeySpaceResolver.java

@@ -24,7 +24,7 @@
  * @author Christoph Strobl
  * @author Oliver Gierke
  */
-enum ClassNameKeySpaceResolver implements KeySpaceResolver {
+public enum ClassNameKeySpaceResolver implements KeySpaceResolver {
 
 	INSTANCE;
 

src/main/java/org/springframework/data/keyvalue/core/mapping/KeySpaceResolver.java

@@ -19,7 +19,7 @@
 
 /**
  * {@link KeySpaceResolver} determines the {@literal keyspace} a given type is assigned to. A keyspace in this context
- * is a specific region/collection/grouping of elements sharing a common keyrange. <br />
+ * is a specific region/collection/grouping of elements sharing a common keyrange.
  *
  * @author Christoph Strobl
  * @author Mark Paluch

src/main/java/org/springframework/data/keyvalue/core/mapping/PrefixKeyspaceResolver.java

@@ -22,7 +22,7 @@
  * delegate {@link KeySpaceResolver}.
  *
  * @author Mark Paluch
- * @since 3.0
+ * @since 3.1
  */
 public class PrefixKeyspaceResolver implements KeySpaceResolver {
 

src/main/java/org/springframework/data/keyvalue/core/mapping/context/KeyValueMappingContext.java

@@ -39,7 +39,7 @@
 public class KeyValueMappingContext<E extends KeyValuePersistentEntity<?, P>, P extends KeyValuePersistentProperty<P>>
 		extends AbstractMappingContext<E, P> {
 
-	private @Nullable KeySpaceResolver fallbackKeySpaceResolver;
+	private @Nullable KeySpaceResolver keySpaceResolver;
 
 	public KeyValueMappingContext() {
 		setSimpleTypeHolder(new KeyValueSimpleTypeHolder());
@@ -49,24 +49,37 @@ public KeyValueMappingContext() {
 	 * Configures the {@link KeySpaceResolver} to be used if not explicit key space is annotated to the domain type.
 	 *
 	 * @param fallbackKeySpaceResolver can be {@literal null}.
+	 * @deprecated since 3.1, use {@link KeySpaceResolver} instead.
 	 */
+	@Deprecated(since = "3.1")
 	public void setFallbackKeySpaceResolver(KeySpaceResolver fallbackKeySpaceResolver) {
-		this.fallbackKeySpaceResolver = fallbackKeySpaceResolver;
+		setKeySpaceResolver(fallbackKeySpaceResolver);
 	}
 
 	/**
-	 * @return the current fallback KeySpaceResolver. Can be {@literal null}.
-	 * @since 3.0
+	 * Configures the {@link KeySpaceResolver} to be used. Configuring a {@link KeySpaceResolver} disables SpEL evaluation
+	 * abilities.
+	 *
+	 * @param keySpaceResolver can be {@literal null}.
+	 * @since 3.1
+	 */
+	public void setKeySpaceResolver(KeySpaceResolver keySpaceResolver) {
+		this.keySpaceResolver = keySpaceResolver;
+	}
+
+	/**
+	 * @return the current {@link KeySpaceResolver}. Can be {@literal null}.
+	 * @since 3.1
 	 */
 	@Nullable
-	public KeySpaceResolver getFallbackKeySpaceResolver() {
-		return fallbackKeySpaceResolver;
+	public KeySpaceResolver getKeySpaceResolver() {
+		return keySpaceResolver;
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	protected <T> E createPersistentEntity(TypeInformation<T> typeInformation) {
-		return (E) new BasicKeyValuePersistentEntity<T, P>(typeInformation, getFallbackKeySpaceResolver());
+		return (E) new BasicKeyValuePersistentEntity<T, P>(typeInformation, getKeySpaceResolver());
 	}
 
 	@Override

src/test/java/org/springframework/data/keyvalue/core/mapping/BasicKeyValuePersistentEntityUnitTests.java

@@ -24,7 +24,6 @@
 import org.junit.jupiter.api.Test;
 import org.springframework.data.keyvalue.annotation.KeySpace;
 import org.springframework.data.keyvalue.core.mapping.context.KeyValueMappingContext;
-import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.spel.ExtensionAwareEvaluationContextProvider;
 import org.springframework.data.spel.spi.EvaluationContextExtension;
 
@@ -35,7 +34,7 @@
  */
 class BasicKeyValuePersistentEntityUnitTests {
 
-	private MappingContext<? extends KeyValuePersistentEntity<?, ?>, ? extends KeyValuePersistentProperty<?>> mappingContext = new KeyValueMappingContext<>();
+	private KeyValueMappingContext<? extends KeyValuePersistentEntity<?, ?>, ? extends KeyValuePersistentProperty<?>> mappingContext = new KeyValueMappingContext<>();
 
 	@Test // DATAKV-268
 	void shouldDeriveKeyspaceFromClassName() {
@@ -64,6 +63,24 @@ void shouldEvaluateEntityWithoutKeyspace() {
 		assertThat(persistentEntity.getKeySpace()).isEqualTo(NoKeyspaceEntity.class.getName());
 	}
 
+	@Test // GH-461
+	void shouldApplyKeySpaceResolver() {
+
+		mappingContext.setKeySpaceResolver(new PrefixKeyspaceResolver("foo", ClassNameKeySpaceResolver.INSTANCE));
+		KeyValuePersistentEntity<?, ?> persistentEntity = mappingContext.getPersistentEntity(NoKeyspaceEntity.class);
+
+		assertThat(persistentEntity.getKeySpace()).isEqualTo("foo" + NoKeyspaceEntity.class.getName());
+	}
+
+	@Test // GH-461
+	void shouldFallBackToDefaultsIfKeySpaceResolverReturnsNull() {
+
+		mappingContext.setKeySpaceResolver(it -> null);
+		KeyValuePersistentEntity<?, ?> persistentEntity = mappingContext.getPersistentEntity(NoKeyspaceEntity.class);
+
+		assertThat(persistentEntity.getKeySpace()).isEqualTo(NoKeyspaceEntity.class.getName());
+	}
+
 	@KeySpace("#{myProperty}")
 	private static class ExpressionEntity {}