Only cache resolved method when coming from ReflectiveMethodResolver

jhoeller · jhoeller · commit 6de67cc2df9f · 2013-09-04T22:00:32.000+02:00
Issue: SPR-9495 (cherry picked from commit b7ff26a)
diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java
@@ -32,6 +32,7 @@
 import org.springframework.expression.spel.ExpressionState;
 import org.springframework.expression.spel.SpelEvaluationException;
 import org.springframework.expression.spel.SpelMessage;
+import org.springframework.expression.spel.support.ReflectiveMethodResolver;
 
 /**
  * Expression language AST node that represents a method reference.
@@ -88,7 +89,7 @@ private TypedValue getValueInternal(EvaluationContext evaluationContext,
 			return TypedValue.NULL;
 		}
 
-		MethodExecutor executorToUse = getCachedExecutor(value, targetType, argumentTypes);
+		MethodExecutor executorToUse = getCachedExecutor(evaluationContext, value, targetType, argumentTypes);
 		if (executorToUse != null) {
 			try {
 				return executorToUse.execute(evaluationContext, value, arguments);
@@ -104,8 +105,7 @@ private TypedValue getValueInternal(EvaluationContext evaluationContext,
 
 				// To determine the situation, the AccessException will contain a cause.
 				// If the cause is an InvocationTargetException, a user exception was
-				// thrown inside the method.
-				// Otherwise the method could not be invoked.
+				// thrown inside the method. Otherwise the method could not be invoked.
 				throwSimpleExceptionIfPossible(value, ae);
 
 				// At this point we know it wasn't a user problem so worth a retry if a
@@ -161,7 +161,16 @@ private List<TypeDescriptor> getArgumentTypes(Object... arguments) {
 		return Collections.unmodifiableList(descriptors);
 	}
 
-	private MethodExecutor getCachedExecutor(Object value, TypeDescriptor target, List<TypeDescriptor> argumentTypes) {
+	private MethodExecutor getCachedExecutor(EvaluationContext evaluationContext, Object value,
+			TypeDescriptor target, List<TypeDescriptor> argumentTypes) {
+
+		List<MethodResolver> methodResolvers = evaluationContext.getMethodResolvers();
+		if (methodResolvers == null || methodResolvers.size() != 1 ||
+				!(methodResolvers.get(0) instanceof ReflectiveMethodResolver)) {
+			// Not a default ReflectiveMethodResolver - don't know whether caching is valid
+			return null;
+		}
+
 		CachedMethodExecutor executorToCheck = this.cachedExecutor;
 		if (executorToCheck != null && executorToCheck.isSuitable(value, target, argumentTypes)) {
 			return executorToCheck.get();
diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/SpelReproTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/SpelReproTests.java
@@ -32,6 +32,7 @@
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
+import org.springframework.core.MethodParameter;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.AccessException;
 import org.springframework.expression.BeanResolver;
@@ -1775,6 +1776,47 @@ public void SPR_10452() throws Exception {
 		assertEquals(XYZ.Z, Array.get(result, 2));
 	}
 
+	@Test
+	public void SPR_9495() throws Exception {
+		SpelParserConfiguration configuration = new SpelParserConfiguration(false, false);
+		ExpressionParser parser = new SpelExpressionParser(configuration);
+
+		StandardEvaluationContext context = new StandardEvaluationContext();
+		Expression spel = parser.parseExpression("#enumType.values()");
+
+		context.setVariable("enumType", ABC.class);
+		Object result = spel.getValue(context);
+		assertNotNull(result);
+		assertTrue(result.getClass().isArray());
+		assertEquals(ABC.A, Array.get(result, 0));
+		assertEquals(ABC.B, Array.get(result, 1));
+		assertEquals(ABC.C, Array.get(result, 2));
+
+		context.addMethodResolver(new MethodResolver() {
+			@Override
+			public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes) throws AccessException {
+				return new MethodExecutor() {
+					@Override
+					public TypedValue execute(EvaluationContext context, Object target, Object... arguments) throws AccessException {
+						try {
+							Method method = XYZ.class.getMethod("values");
+							Object value = method.invoke(target, arguments);
+							return new TypedValue(value, new TypeDescriptor(new MethodParameter(method, -1)).narrow(value));
+						}
+						catch (Exception ex) {
+							throw new AccessException(ex.getMessage(), ex);
+						}
+					}
+				};
+			}
+		});
+		result = spel.getValue(context);
+		assertNotNull(result);
+		assertTrue(result.getClass().isArray());
+		assertEquals(XYZ.X, Array.get(result, 0));
+		assertEquals(XYZ.Y, Array.get(result, 1));
+		assertEquals(XYZ.Z, Array.get(result, 2));
+	}
 
 
 	private static enum ABC {A, B, C}
