Backported DataBindingPropertyAccessor and DataBindingMethodResolver

Issue: SPR-16588

Author: jhoeller

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -22,9 +22,9 @@
  * Expressions are executed in an evaluation context. It is in this context that
  * references are resolved when encountered during expression evaluation.
  *
- * <p>There is a default implementation of the EvaluationContext,
- * {@link org.springframework.expression.spel.support.StandardEvaluationContext} that can
- * be extended, rather than having to implement everything.
+ * <p>There is a default implementation of this EvaluationContext interface:
+ * {@link org.springframework.expression.spel.support.StandardEvaluationContext}
+ * which can be extended, rather than having to implement everything manually.
  *
  * @author Andy Clement
  * @author Juergen Hoeller
@@ -39,6 +39,11 @@ public interface EvaluationContext {
 	 */
 	TypedValue getRootObject();
 
+	/**
+	 * Return a list of accessors that will be asked in turn to read/write a property.
+	 */
+	List<PropertyAccessor> getPropertyAccessors();
+
 	/**
 	 * Return a list of resolvers that will be asked in turn to locate a constructor.
 	 */
@@ -50,9 +55,9 @@ public interface EvaluationContext {
 	List<MethodResolver> getMethodResolvers();
 
 	/**
-	 * Return a list of accessors that will be asked in turn to read/write a property.
+	 * Return a bean resolver that can look up beans by name.
 	 */
-	List<PropertyAccessor> getPropertyAccessors();
+	BeanResolver getBeanResolver();
 
 	/**
 	 * Return a type locator that can be used to find types, either by short or
@@ -76,11 +81,6 @@ public interface EvaluationContext {
 	 */
 	OperatorOverloader getOperatorOverloader();
 
-	/**
-	 * Return a bean resolver that can look up beans by name.
-	 */
-	BeanResolver getBeanResolver();
-
 	/**
 	 * Set a named variable within this evaluation context to a specified value.
 	 * @param name variable to set
@@ -91,7 +91,7 @@ public interface EvaluationContext {
 	/**
 	 * Look up a named variable within this evaluation context.
 	 * @param name variable to lookup
-	 * @return the value of the variable
+	 * @return the value of the variable, or {@code null} if not found
 	 */
 	Object lookupVariable(String name);
 

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2002-2018 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.expression.spel.support;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.List;
+
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.expression.AccessException;
+import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.MethodExecutor;
+
+/**
+ * A {@link org.springframework.expression.MethodResolver} variant for data binding
+ * purposes, using reflection to access instance methods on a given target object.
+ *
+ * <p>This accessor does not resolve static methods and also no technical methods
+ * on {@code java.lang.Object} or {@code java.lang.Class}.
+ * For unrestricted resolution, choose {@link ReflectiveMethodResolver} instead.
+ *
+ * @author Juergen Hoeller
+ * @since 4.3.15
+ * @see #forInstanceMethodInvocation()
+ * @see DataBindingPropertyAccessor
+ */
+public class DataBindingMethodResolver extends ReflectiveMethodResolver {
+
+	private DataBindingMethodResolver() {
+		super();
+	}
+
+	@Override
+	public MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
+			List<TypeDescriptor> argumentTypes) throws AccessException {
+
+		if (targetObject instanceof Class) {
+			throw new IllegalArgumentException("DataBindingMethodResolver does not support Class targets");
+		}
+		return super.resolve(context, targetObject, name, argumentTypes);
+	}
+
+	@Override
+	protected boolean isCandidateForInvocation(Method method, Class<?> targetClass) {
+		if (Modifier.isStatic(method.getModifiers())) {
+			return false;
+		}
+		Class<?> clazz = method.getDeclaringClass();
+		return (clazz != Object.class && clazz != Class.class && !ClassLoader.class.isAssignableFrom(targetClass));
+	}
+
+
+	/**
+	 * Create a new data-binding method resolver for instance method resolution.
+	 */
+	public static DataBindingMethodResolver forInstanceMethodInvocation() {
+		return new DataBindingMethodResolver();
+	}
+
+}

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2002-2018 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.expression.spel.support;
+
+import java.lang.reflect.Method;
+
+/**
+ * A {@link org.springframework.expression.PropertyAccessor} variant for data binding
+ * purposes, using reflection to access properties for reading and possibly writing.
+ *
+ * <p>A property can be referenced through a public getter method (when being read)
+ * or a public setter method (when being written), and also as a public field.
+ *
+ * <p>This accessor is explicitly designed for user-declared properties and does not
+ * resolve technical properties on {@code java.lang.Object} or {@code java.lang.Class}.
+ * For unrestricted resolution, choose {@link ReflectivePropertyAccessor} instead.
+ *
+ * @author Juergen Hoeller
+ * @since 4.3.15
+ * @see #forReadOnlyAccess()
+ * @see #forReadWriteAccess()
+ * @see SimpleEvaluationContext
+ * @see StandardEvaluationContext
+ * @see ReflectivePropertyAccessor
+ */
+public class DataBindingPropertyAccessor extends ReflectivePropertyAccessor {
+
+	/**
+	 * Create a new property accessor for reading and possibly also writing.
+	 * @param allowWrite whether to also allow for write operations
+	 * @see #canWrite
+	 */
+	private DataBindingPropertyAccessor(boolean allowWrite) {
+		super(allowWrite);
+	}
+
+	@Override
+	protected boolean isCandidateForProperty(Method method, Class<?> targetClass) {
+		Class<?> clazz = method.getDeclaringClass();
+		return (clazz != Object.class && clazz != Class.class && !ClassLoader.class.isAssignableFrom(targetClass));
+	}
+
+
+	/**
+	 * Create a new data-binding property accessor for read-only operations.
+	 */
+	public static DataBindingPropertyAccessor forReadOnlyAccess() {
+		return new DataBindingPropertyAccessor(false);
+	}
+
+	/**
+	 * Create a new data-binding property accessor for read-write operations.
+	 */
+	public static DataBindingPropertyAccessor forReadWriteAccess() {
+		return new DataBindingPropertyAccessor(true);
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -21,7 +21,6 @@
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -81,6 +80,12 @@ public ReflectiveMethodResolver(boolean useDistance) {
 	}
 
 
+	/**
+	 * Register a filter for methods on the given type.
+	 * @param type the type to filter on
+	 * @param filter the corresponding method filter,
+	 * or {@code null} to clear any filter for the given type
+	 */
 	public void registerMethodFilter(Class<?> type, MethodFilter filter) {
 		if (this.filters == null) {
 			this.filters = new HashMap<Class<?>, MethodFilter>();
@@ -93,7 +98,6 @@ public void registerMethodFilter(Class<?> type, MethodFilter filter) {
 		}
 	}
 
-
 	/**
 	 * Locate a method on a type. There are three kinds of match that might occur:
 	 * <ol>
@@ -219,7 +223,7 @@ else if (matchRequiringConversion != null) {
 		}
 	}
 
-	private Collection<Method> getMethods(Class<?> type, Object targetObject) {
+	private Set<Method> getMethods(Class<?> type, Object targetObject) {
 		if (targetObject instanceof Class) {
 			Set<Method> result = new LinkedHashSet<Method>();
 			// Add these so that static methods are invocable on the type: e.g. Float.valueOf(..)
@@ -237,12 +241,24 @@ else if (Proxy.isProxyClass(type)) {
 			Set<Method> result = new LinkedHashSet<Method>();
 			// Expose interface methods (not proxy-declared overrides) for proper vararg introspection
 			for (Class<?> ifc : type.getInterfaces()) {
-				result.addAll(Arrays.asList(getMethods(ifc)));
+				Method[] methods = getMethods(ifc);
+				for (Method method : methods) {
+					if (isCandidateForInvocation(method, type)) {
+						result.add(method);
+					}
+				}
 			}
 			return result;
 		}
 		else {
-			return Arrays.asList(getMethods(type));
+			Set<Method> result = new LinkedHashSet<Method>();
+			Method[] methods = getMethods(type);
+			for (Method method : methods) {
+				if (isCandidateForInvocation(method, type)) {
+					result.add(method);
+				}
+			}
+			return result;
 		}
 	}
 
@@ -258,4 +274,17 @@ protected Method[] getMethods(Class<?> type) {
 		return type.getMethods();
 	}
 
+	/**
+	 * Determine whether the given {@code Method} is a candidate for method resolution
+	 * on an instance of the given target class.
+	 * <p>The default implementation considers any method as a candidate, even for
+	 * static methods sand non-user-declared methods on the {@link Object} base class.
+	 * @param method the Method to evaluate
+	 * @param targetClass the concrete target class that is being introspected
+	 * @since 4.3.15
+	 */
+	protected boolean isCandidateForInvocation(Method method, Class<?> targetClass) {
+		return true;
+	}
+
 }