1. add indexAccessor for SpEL.

closes gh-26409

Author: ljmn3211

spring-expression/spring-expression.gradle

@@ -7,4 +7,6 @@ dependencies {
 	testCompile(testFixtures(project(":spring-core")))
 	testCompile("org.jetbrains.kotlin:kotlin-reflect")
 	testCompile("org.jetbrains.kotlin:kotlin-stdlib")
+	testCompile("com.fasterxml.jackson.core:jackson-databind")
+	testCompile("com.fasterxml.jackson.core:jackson-core")
 }

spring-expression/src/main/java/org/springframework/expression/EvaluationContext.java

@@ -46,6 +46,11 @@ public interface EvaluationContext {
 	 */
 	List<PropertyAccessor> getPropertyAccessors();
 
+	/**
+	 * Return a list of index accessors that will be asked in turn to read/write a property.
+	 */
+	List<IndexAccessor> getIndexAccessors();
+
 	/**
 	 * Return a list of resolvers that will be asked in turn to locate a constructor.
 	 */

spring-expression/src/main/java/org/springframework/expression/IndexAccessor.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2002-2019 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
+ *
+ *      https://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.expression;
+
+import org.springframework.expression.spel.ast.ValueRef;
+import org.springframework.lang.Nullable;
+
+/**
+ * A index accessor is able to read from (and possibly write to) an array's elements.
+ *
+ * <p>This interface places no restrictions, and so implementors are free to access elements
+ * directly as fields or through getters or in any other way they see as appropriate.
+ *
+ * <p>A resolver can optionally specify an array of target classes for which it should be
+ * called. However, if it returns {@code null} from {@link #getSpecificTargetClasses()},
+ * it will be called for all property references and given a chance to determine if it
+ * can read or write them.
+ *
+ * <p>Property resolvers are considered to be ordered, and each will be called in turn.
+ * The only rule that affects the call order is that any resolver naming the target
+ * class directly in {@link #getSpecificTargetClasses()} will be called first, before
+ * the general resolvers.
+ *
+ * @author jackmiking lee
+ * @since 3.0
+ */
+public interface IndexAccessor {
+	/**
+	 * Return an array of classes for which this resolver should be called.
+	 * <p>Returning {@code null} indicates this is a general resolver that
+	 * can be called in an attempt to resolve a property on any type.
+	 * @return an array of classes that this resolver is suitable for
+	 * (or {@code null} if a general resolver)
+	 */
+	@Nullable
+	Class<?>[] getSpecificTargetClasses();
+
+	/**
+	 * Called to determine if a resolver instance is able to access a specified property
+	 * on a specified target object.
+	 * @param context the evaluation context in which the access is being attempted
+	 * @param target the target object upon which the property is being accessed
+	 * @param index the index of the array being accessed
+	 * @return true if this resolver is able to read the property
+	 * @throws AccessException if there is any problem determining whether the property can be read
+	 */
+	boolean canRead(EvaluationContext context, @Nullable Object target, Object index) throws AccessException;
+
+	/**
+	 * Called to read a property from a specified target object.
+	 * Should only succeed if {@link #canRead} also returns {@code true}.
+	 * @param context the evaluation context in which the access is being attempted
+	 * @param target the target object upon which the property is being accessed
+	 * @param index the index of the array being accessed
+	 * @return a TypedValue object wrapping the property value read and a type descriptor for it
+	 * @throws AccessException if there is any problem accessing the property value
+	 */
+	ValueRef read(EvaluationContext context, @Nullable Object target,Object index) throws AccessException;
+
+	/**
+	 * Called to determine if a resolver instance is able to write to a specified
+	 * property on a specified target object.
+	 * @param context the evaluation context in which the access is being attempted
+	 * @param target the target object upon which the property is being accessed
+	 * @param index the index of the array being accessed
+	 * @return true if this resolver is able to write to the property
+	 * @throws AccessException if there is any problem determining whether the
+	 * property can be written to
+	 */
+	boolean canWrite(EvaluationContext context, @Nullable Object target, Object index) throws AccessException;
+
+	/**
+	 * Called to write to a property on a specified target object.
+	 * Should only succeed if {@link #canWrite} also returns {@code true}.
+	 * @param context the evaluation context in which the access is being attempted
+	 * @param target the target object upon which the property is being accessed
+	 * @param index the index of the array being accessed
+	 * @param newValue the new value for the property
+	 * @throws AccessException if there is any problem writing to the property value
+	 */
+	void write(EvaluationContext context, @Nullable Object target, Object index, @Nullable Object newValue)
+			throws AccessException;
+}

spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java

@@ -21,16 +21,19 @@
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.StringJoiner;
 
 import org.springframework.asm.MethodVisitor;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.AccessException;
 import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.EvaluationException;
+import org.springframework.expression.IndexAccessor;
 import org.springframework.expression.PropertyAccessor;
 import org.springframework.expression.TypeConverter;
 import org.springframework.expression.TypedValue;
@@ -187,11 +190,73 @@ else if (target instanceof Collection) {
 			return new PropertyIndexingValueRef(
 					target, (String) index, state.getEvaluationContext(), targetDescriptor);
 		}
-
+		Optional<ValueRef> optional = tryIndexAccessor(state, index);
+		if (optional.isPresent()) {
+			return optional.get();
+		}
 		throw new SpelEvaluationException(
 				getStartPosition(), SpelMessage.INDEXING_NOT_SUPPORTED_FOR_TYPE, targetDescriptor);
 	}
 
+	private Optional<ValueRef> tryIndexAccessor(ExpressionState state, Object index) {
+		EvaluationContext context = state.getEvaluationContext();
+		Object target = state.getActiveContextObject().getValue();
+		if (context != null) {
+			List<IndexAccessor> list = context.getIndexAccessors();
+			if (list != null) {
+				List<IndexAccessor> availableAccessors = getIndexAccessorsToTry(state.getActiveContextObject(), list);
+				try {
+					for (IndexAccessor indexAccessor : availableAccessors) {
+						if (indexAccessor.canRead(context, target, index)) {
+							ValueRef valueRef = indexAccessor.read(context, target, index);
+							return Optional.of(valueRef);
+						}
+					}
+				}
+				catch (Exception ex) {
+				}
+			}
+		}
+		return Optional.empty();
+	}
+
+	private List<IndexAccessor> getIndexAccessorsToTry(
+			@Nullable Object contextObject, List<IndexAccessor> propertyAccessors) {
+		
+		Class<?> targetType;
+		if (contextObject instanceof TypedValue) {
+			targetType = ((TypedValue) contextObject).getTypeDescriptor().getObjectType();
+		}
+		else {
+			targetType = (contextObject != null ? contextObject.getClass() : null);
+		}
+
+		List<IndexAccessor> specificAccessors = new ArrayList<>();
+		List<IndexAccessor> generalAccessors = new ArrayList<>();
+		for (IndexAccessor resolver : propertyAccessors) {
+			Class<?>[] targets = resolver.getSpecificTargetClasses();
+			if (targets == null) {
+				// generic resolver that says it can be used for any type
+				generalAccessors.add(resolver);
+			}
+			else if (targetType != null) {
+				for (Class<?> clazz : targets) {
+					if (clazz == targetType) {
+						specificAccessors.add(resolver);
+						break;
+					}
+					else if (clazz.isAssignableFrom(targetType)) {
+						generalAccessors.add(resolver);
+					}
+				}
+			}
+		}
+		List<IndexAccessor> resolvers = new ArrayList<>(specificAccessors);
+		generalAccessors.removeAll(specificAccessors);
+		resolvers.addAll(generalAccessors);
+		return resolvers;
+	}
+
 	@Override
 	public boolean isCompilable() {
 		if (this.indexedType == IndexedType.ARRAY) {

spring-expression/src/main/java/org/springframework/expression/spel/support/SimpleEvaluationContext.java

@@ -27,6 +27,7 @@
 import org.springframework.expression.BeanResolver;
 import org.springframework.expression.ConstructorResolver;
 import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.IndexAccessor;
 import org.springframework.expression.MethodResolver;
 import org.springframework.expression.OperatorOverloader;
 import org.springframework.expression.PropertyAccessor;
@@ -135,6 +136,11 @@ public List<PropertyAccessor> getPropertyAccessors() {
 		return this.propertyAccessors;
 	}
 
+	@Override
+	public List<IndexAccessor> getIndexAccessors() {
+		return null;
+	}
+
 	/**
 	 * Return an empty list, always, since this context does not support the
 	 * use of type references.

spring-expression/src/main/java/org/springframework/expression/spel/support/StandardEvaluationContext.java

@@ -26,6 +26,7 @@
 import org.springframework.expression.BeanResolver;
 import org.springframework.expression.ConstructorResolver;
 import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.IndexAccessor;
 import org.springframework.expression.MethodFilter;
 import org.springframework.expression.MethodResolver;
 import org.springframework.expression.OperatorOverloader;
@@ -66,6 +67,9 @@ public class StandardEvaluationContext implements EvaluationContext {
 	@Nullable
 	private volatile List<PropertyAccessor> propertyAccessors;
 
+	@Nullable
+	private volatile List<IndexAccessor> indexAccessors;
+
 	@Nullable
 	private volatile List<ConstructorResolver> constructorResolvers;
 
@@ -125,6 +129,10 @@ public void setPropertyAccessors(List<PropertyAccessor> propertyAccessors) {
 		this.propertyAccessors = propertyAccessors;
 	}
 
+	public void setIndexAccessors(List<IndexAccessor>indexAccessors){
+		this.indexAccessors=indexAccessors;
+	}
+
 	@Override
 	public List<PropertyAccessor> getPropertyAccessors() {
 		return initPropertyAccessors();
@@ -138,6 +146,14 @@ public boolean removePropertyAccessor(PropertyAccessor accessor) {
 		return initPropertyAccessors().remove(accessor);
 	}
 
+	public void addIndexAccessor(IndexAccessor accessor){
+		initIndexAccessors().add(accessor);
+	}
+
+	public boolean removeIndexAccessor(IndexAccessor indexAccessor){
+		return initIndexAccessors().remove(indexAccessor);
+	}
+
 	public void setConstructorResolvers(List<ConstructorResolver> constructorResolvers) {
 		this.constructorResolvers = constructorResolvers;
 	}
@@ -287,6 +303,15 @@ private List<PropertyAccessor> initPropertyAccessors() {
 		return accessors;
 	}
 
+	private List<IndexAccessor>initIndexAccessors(){
+		List<IndexAccessor> accessors = this.indexAccessors;
+		if(accessors == null){
+			accessors = new ArrayList<>(5);
+			this.indexAccessors = accessors;
+		}
+		return accessors;
+	}
+
 	private List<ConstructorResolver> initConstructorResolvers() {
 		List<ConstructorResolver> resolvers = this.constructorResolvers;
 		if (resolvers == null) {
@@ -312,4 +337,9 @@ private static <T> void addBeforeDefault(List<T> resolvers, T resolver) {
 		resolvers.add(resolvers.size() - 1, resolver);
 	}
 
+	@Override
+	public List<IndexAccessor> getIndexAccessors() {
+		return initIndexAccessors();
+	}
+
 }