DATAREDIS-425 - Index definition and setup refactoring.

Remove IndexType and use dedicated classes for index definitions.

Author: christophstrobl

src/main/java/org/springframework/data/redis/core/RedisKeyValueAdapter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,9 +40,9 @@
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.convert.CustomConversions;
-import org.springframework.data.redis.core.convert.IndexResolverImpl;
 import org.springframework.data.redis.core.convert.KeyspaceConfiguration;
 import org.springframework.data.redis.core.convert.MappingRedisConverter;
+import org.springframework.data.redis.core.convert.PathIndexResolver;
 import org.springframework.data.redis.core.convert.RedisConverter;
 import org.springframework.data.redis.core.convert.RedisData;
 import org.springframework.data.redis.core.convert.ReferenceResolver;
@@ -131,8 +131,8 @@ public RedisKeyValueAdapter(RedisOperations<?, ?> redisOps, RedisMappingContext
 		Assert.notNull(redisOps, "RedisOperations must not be null!");
 		Assert.notNull(mappingContext, "RedisMappingContext must not be null!");
 
-		MappingRedisConverter mappingConverter = new MappingRedisConverter(mappingContext, new IndexResolverImpl(
-				mappingContext), new ReferenceResolverImpl(this));
+		MappingRedisConverter mappingConverter = new MappingRedisConverter(mappingContext,
+				new PathIndexResolver(mappingContext), new ReferenceResolverImpl(this));
 		mappingConverter.setCustomConversions(customConversions == null ? new CustomConversions() : customConversions);
 		mappingConverter.afterPropertiesSet();
 

src/main/java/org/springframework/data/redis/core/convert/MappingConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
  */
 package org.springframework.data.redis.core.convert;
 
-import org.springframework.data.redis.core.index.IndexConfiguration;
+import org.springframework.data.redis.core.index.ConfigurableIndexDefinitionProvider;
 
 /**
  * {@link MappingConfiguration} is used for programmatic configuration of secondary indexes, key prefixes, expirations
@@ -26,7 +26,7 @@
  */
 public class MappingConfiguration {
 
-	private final IndexConfiguration indexConfiguration;
+	private final ConfigurableIndexDefinitionProvider indexConfiguration;
 	private final KeyspaceConfiguration keyspaceConfiguration;
 
 	/**
@@ -35,7 +35,8 @@ public class MappingConfiguration {
 	 * @param indexConfiguration must not be {@literal null}.
 	 * @param keyspaceConfiguration must not be {@literal null}.
 	 */
-	public MappingConfiguration(IndexConfiguration indexConfiguration, KeyspaceConfiguration keyspaceConfiguration) {
+	public MappingConfiguration(ConfigurableIndexDefinitionProvider indexConfiguration,
+			KeyspaceConfiguration keyspaceConfiguration) {
 
 		this.indexConfiguration = indexConfiguration;
 		this.keyspaceConfiguration = keyspaceConfiguration;
@@ -44,7 +45,7 @@ public MappingConfiguration(IndexConfiguration indexConfiguration, KeyspaceConfi
 	/**
 	 * @return never {@literal null}.
 	 */
-	public IndexConfiguration getIndexConfiguration() {
+	public ConfigurableIndexDefinitionProvider getIndexConfiguration() {
 		return indexConfiguration;
 	}
 

src/main/java/org/springframework/data/redis/core/convert/MappingRedisConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2016 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -138,7 +138,7 @@ public MappingRedisConverter(RedisMappingContext mappingContext, IndexResolver i
 
 		this.referenceResolver = referenceResolver;
 
-		this.indexResolver = indexResolver != null ? indexResolver : new IndexResolverImpl(this.mappingContext);
+		this.indexResolver = indexResolver != null ? indexResolver : new PathIndexResolver(this.mappingContext);
 	}
 
 	/*

src/main/java/org/springframework/data/redis/core/convert/IndexResolverImpl.java renamed to src/main/java/org/springframework/data/redis/core/convert/PathIndexResolver.java

@@ -25,9 +25,13 @@
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.redis.core.index.ConfigurableIndexDefinitionProvider;
 import org.springframework.data.redis.core.index.IndexConfiguration;
-import org.springframework.data.redis.core.index.IndexConfiguration.RedisIndexSetting;
+import org.springframework.data.redis.core.index.IndexDefinition;
+import org.springframework.data.redis.core.index.IndexDefinition.Condition;
+import org.springframework.data.redis.core.index.IndexDefinition.IndexingContext;
 import org.springframework.data.redis.core.index.Indexed;
+import org.springframework.data.redis.core.index.SimpleIndexDefinition;
 import org.springframework.data.redis.core.mapping.RedisMappingContext;
 import org.springframework.data.redis.core.mapping.RedisPersistentEntity;
 import org.springframework.data.util.ClassTypeInformation;
@@ -41,24 +45,24 @@
  * @author Christoph Strobl
  * @since 1.7
  */
-public class IndexResolverImpl implements IndexResolver {
+public class PathIndexResolver implements IndexResolver {
 
-	private IndexConfiguration indexConfiguration;
+	private ConfigurableIndexDefinitionProvider indexConfiguration;
 	private RedisMappingContext mappingContext;
 
 	/**
-	 * Creates new {@link IndexResolverImpl} with empty {@link IndexConfiguration}.
+	 * Creates new {@link PathIndexResolver} with empty {@link IndexConfiguration}.
 	 */
-	public IndexResolverImpl() {
+	public PathIndexResolver() {
 		this(new RedisMappingContext());
 	}
 
 	/**
-	 * Creates new {@link IndexResolverImpl} with given {@link IndexConfiguration}.
+	 * Creates new {@link PathIndexResolver} with given {@link IndexConfiguration}.
 	 *
 	 * @param mapppingContext must not be {@literal null}.
 	 */
-	public IndexResolverImpl(RedisMappingContext mappingContext) {
+	public PathIndexResolver(RedisMappingContext mappingContext) {
 
 		Assert.notNull(mappingContext, "MappingContext must not be null!");
 		this.mappingContext = mappingContext;
@@ -160,28 +164,43 @@ protected Set<IndexedData> resolveIndex(String keyspace, String propertyPath, Pe
 		Set<IndexedData> data = new LinkedHashSet<IndexedData>();
 
 		if (indexConfiguration.hasIndexFor(keyspace, path)) {
-			for (RedisIndexSetting indexSetting : indexConfiguration.getIndexDefinitionsFor(keyspace, path)) {
-				data.add(new SimpleIndexedPropertyValue(keyspace, indexSetting.getIndexName(), value));
-			}
 
+			IndexingContext context = new IndexingContext(keyspace, path, property != null ? property.getTypeInformation()
+					: ClassTypeInformation.OBJECT);
+
+			for (IndexDefinition indexDefinition : indexConfiguration.getIndexDefinitionsFor(keyspace, path)) {
+
+				if (!verifyConditions(indexDefinition.getConditions(), value, context)) {
+					continue;
+				}
+
+				data.add(new SimpleIndexedPropertyValue(keyspace, indexDefinition.getIndexName(), indexDefinition
+						.valueTransformer().convert(value)));
+			}
 		}
 
 		else if (property != null && property.isAnnotationPresent(Indexed.class)) {
 
-			Indexed indexed = property.findAnnotation(Indexed.class);
+			SimpleIndexDefinition indexDefinition = new SimpleIndexDefinition(keyspace, path);
+			indexConfiguration.addIndexDefinition(indexDefinition);
 
-			indexConfiguration.addIndexDefinition(new RedisIndexSetting(keyspace, path, indexed.type()));
+			data.add(new SimpleIndexedPropertyValue(keyspace, path, indexDefinition.valueTransformer().convert(value)));
+		}
+		return data;
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private boolean verifyConditions(Iterable<Condition<?>> conditions, Object value, IndexingContext context) {
 
-			switch (indexed.type()) {
-				case SIMPLE:
-					data.add(new SimpleIndexedPropertyValue(keyspace, path, value));
-					break;
-				default:
-					throw new IllegalArgumentException(String.format("Unsupported index type '%s' for path '%s'.",
-							indexed.type(), path));
+		for (Condition condition : conditions) {
+
+			// TODO: generics lookup
+			if (!condition.matches(value, context)) {
+				return false;
 			}
 		}
-		return data;
+
+		return true;
 	}
 
 	private String normalizeIndexPath(String path, PersistentProperty<?> property) {

src/main/java/org/springframework/data/redis/core/convert/SpelIndexResolver.java

@@ -16,13 +16,16 @@
 package org.springframework.data.redis.core.convert;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 
 import org.springframework.context.expression.BeanFactoryResolver;
 import org.springframework.data.keyvalue.core.mapping.KeyValuePersistentEntity;
-import org.springframework.data.redis.core.index.IndexConfiguration;
-import org.springframework.data.redis.core.index.IndexConfiguration.RedisIndexSetting;
+import org.springframework.data.redis.core.index.ConfigurableIndexDefinitionProvider;
+import org.springframework.data.redis.core.index.IndexDefinition;
+import org.springframework.data.redis.core.index.SpelIndexDefinition;
 import org.springframework.data.redis.core.mapping.RedisMappingContext;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.expression.BeanResolver;
@@ -35,16 +38,19 @@
  * An {@link IndexResolver} that resolves {@link IndexedData} using a {@link SpelExpressionParser}.
  *
  * @author Rob Winch
+ * @author Christoph Strobl
  * @since 1.7
  */
 public class SpelIndexResolver implements IndexResolver {
 
-	private final IndexConfiguration settings;
+	private final ConfigurableIndexDefinitionProvider settings;
 	private final SpelExpressionParser parser;
 	private final RedisMappingContext mappingContext;
 
 	private BeanResolver beanResolver;
 
+	private Map<SpelIndexDefinition, Expression> expressionCache;
+
 	/**
 	 * Creates a new instance using a default {@link SpelExpressionParser}.
 	 *
@@ -66,6 +72,7 @@ public SpelIndexResolver(RedisMappingContext mappingContext, SpelExpressionParse
 		Assert.notNull(parser, "SpelExpressionParser must not be null!");
 		this.mappingContext = mappingContext;
 		this.settings = mappingContext.getMappingConfiguration().getIndexConfiguration();
+		this.expressionCache = new HashMap<SpelIndexDefinition, Expression>();
 		this.parser = parser;
 	}
 
@@ -88,26 +95,41 @@ public Set<IndexedData> resolveIndexesFor(TypeInformation<?> typeInformation, Ob
 
 		Set<IndexedData> indexes = new HashSet<IndexedData>();
 
-		for (RedisIndexSetting setting : settings.getIndexDefinitionsFor(keyspace)) {
+		for (IndexDefinition setting : settings.getIndexDefinitionsFor(keyspace)) {
 
-			Expression expression = parser.parseExpression(setting.getPath());
-			StandardEvaluationContext context = new StandardEvaluationContext();
-			context.setRootObject(value);
-			context.setVariable("this", value);
+			if (setting instanceof SpelIndexDefinition) {
 
-			if (beanResolver != null) {
-				context.setBeanResolver(beanResolver);
-			}
+				Expression expression = getAndCacheIfAbsent((SpelIndexDefinition) setting);
+
+				StandardEvaluationContext context = new StandardEvaluationContext();
+				context.setRootObject(value);
+				context.setVariable("this", value);
 
-			Object index = expression.getValue(context);
-			if (index != null) {
-				indexes.add(new SimpleIndexedPropertyValue(keyspace, setting.getIndexName(), index));
+				if (beanResolver != null) {
+					context.setBeanResolver(beanResolver);
+				}
+
+				Object index = expression.getValue(context);
+				if (index != null) {
+					indexes.add(new SimpleIndexedPropertyValue(keyspace, setting.getIndexName(), index));
+				}
 			}
 		}
 
 		return indexes;
 	}
 
+	private Expression getAndCacheIfAbsent(SpelIndexDefinition indexDefinition) {
+
+		if (expressionCache.containsKey(indexDefinition)) {
+			return expressionCache.get(indexDefinition);
+		}
+
+		Expression expression = parser.parseExpression(indexDefinition.getExpression());
+		expressionCache.put(indexDefinition, expression);
+		return expression;
+	}
+
 	/**
 	 * Allows setting the BeanResolver
 	 *

src/main/java/org/springframework/data/redis/core/index/ConfigurableIndexDefinitionProvider.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.core.index;
+
+/**
+ * {@link IndexDefinitionProvider} that allows registering new {@link IndexDefinition} via
+ * {@link IndexDefinitionRegistry}.
+ * 
+ * @author Christoph Strobl
+ * @since 1.7
+ */
+public interface ConfigurableIndexDefinitionProvider extends IndexDefinitionProvider, IndexDefinitionRegistry {
+
+}