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

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

@@ -25,7 +25,7 @@ import org.springframework.lang.Nullable;
 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);
+	}
+
+	/**
+	 * @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);
+	}
+
+	private BasicKeyValuePersistentEntity(TypeInformation<T> information, @Nullable String keyspace) {
 
 		super(information);
 
-		Class<T> type = information.getType();
-		String keySpace = AnnotationBasedKeySpaceResolver.INSTANCE.resolveKeySpace(type);
+		if (StringUtils.hasText(keyspace)) {
 
-		if (StringUtils.hasText(keySpace)) {
-
-			this.keyspace = keySpace;
-			this.keyspaceExpression = detectExpression(keySpace);
+			this.keyspace = keyspace;
+			this.keyspaceExpression = null;
 		} else {
 
-			this.keyspace = resolveKeyspace(fallbackKeySpaceResolver, type);
-			this.keyspaceExpression = null;
+			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 @@ public class BasicKeyValuePersistentEntity<T, P extends KeyValuePersistentProper
 		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 @@ import org.springframework.util.ClassUtils;
  * @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 @@ import org.springframework.lang.Nullable;
 
 /**
  * {@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 @@ import org.springframework.util.Assert;
  * 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 @@ import org.springframework.lang.Nullable;
 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 class KeyValueMappingContext<E extends KeyValuePersistentEntity<?, P>, P
 	 * 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