Consistent method selection for listeners and endpoint mappings

Issue: SPR-13654

spring-core/src/main/java/org/springframework/core/MethodIntrospector.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2002-2015 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.core;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * Defines the algorithm for searching for metadata-associated methods exhaustively
+ * including interfaces and parent classes while also dealing with parameterized methods
+ * as well as common scenarios encountered with interface and class-based proxies.
+ *
+ * <p>Typically, but not necessarily, used for finding annotated handler methods.
+ *
+ * @author Juergen Hoeller
+ * @author Rossen Stoyanchev
+ * @since 4.2.3
+ */
+public abstract class MethodIntrospector {
+
+	/**
+	 * Select methods on the given target type based on the lookup of associated metadata.
+	 * <p>Callers define methods of interest through the {@link MetadataLookup} parameter,
+	 * allowing to collect the associated metadata into the result map.
+	 * @param targetType the target type to search methods on
+	 * @param metadataLookup a {@link MetadataLookup} callback to inspect methods of interest,
+	 * returning non-null metadata to be associated with a given method if there is a match,
+	 * or {@code null} for no match
+	 * @return the selected methods associated with their metadata (in the order of retrieval),
+	 * or an empty map in case of no match
+	 */
+	public static <T> Map<Method, T> selectMethods(Class<?> targetType, final MetadataLookup<T> metadataLookup) {
+		final Map<Method, T> methodMap = new LinkedHashMap<Method, T>();
+		Set<Class<?>> handlerTypes = new LinkedHashSet<Class<?>>();
+		Class<?> specificHandlerType = null;
+
+		if (!Proxy.isProxyClass(targetType)) {
+			handlerTypes.add(targetType);
+			specificHandlerType = targetType;
+		}
+		handlerTypes.addAll(Arrays.asList(targetType.getInterfaces()));
+
+		for (Class<?> currentHandlerType : handlerTypes) {
+			final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
+
+			ReflectionUtils.doWithMethods(currentHandlerType, new ReflectionUtils.MethodCallback() {
+				@Override
+				public void doWith(Method method) {
+					Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
+					T result = metadataLookup.inspect(specificMethod);
+					if (result != null) {
+						Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
+						if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) {
+							methodMap.put(specificMethod, result);
+						}
+					}
+				}
+			}, ReflectionUtils.USER_DECLARED_METHODS);
+		}
+
+		return methodMap;
+	}
+
+	/**
+	 * Select methods on the given target type based on a filter.
+	 * <p>Callers define methods of interest through the
+	 * {@link ReflectionUtils.MethodFilter} parameter.
+	 * @param targetType the target type to search methods on
+	 * @param methodFilter a {@link ReflectionUtils.MethodFilter} to help
+	 * recognize handler methods of interest
+	 * @return the selected methods, or an empty set in case of no match
+	 */
+	public static Set<Method> selectMethods(Class<?> targetType, final ReflectionUtils.MethodFilter methodFilter) {
+		return selectMethods(targetType, new MetadataLookup<Boolean>() {
+			@Override
+			public Boolean inspect(Method method) {
+				return (methodFilter.matches(method) ? Boolean.TRUE : null);
+			}
+		}).keySet();
+	}
+
+	/**
+	 * Select an invocable method on the target type: either the given method itself
+	 * if actually exposed on the target type, or otherwise a corresponding method
+	 * on one of the target type's interfaces or on the target type itself.
+	 * <p>Matches on user-declared interfaces will be preferred since they are likely
+	 * to contain relevant metadata that corresponds to the method on the target class.
+	 * @param method the method to check
+	 * @param targetType the target type to search methods on
+	 * (typically an interface-based JDK proxy)
+	 * @return a corresponding invocable method on the target type
+	 */
+	public static Method selectInvocableMethod(Method method, Class<?> targetType) {
+		if (method.getDeclaringClass().isAssignableFrom(targetType)) {
+			return method;
+		}
+		try {
+			for (Class<?> ifc : targetType.getInterfaces()) {
+				try {
+					return ifc.getMethod(method.getName(), method.getParameterTypes());
+				}
+				catch (NoSuchMethodException ex) {
+					// Alright, not on this interface then...
+				}
+			}
+			// A final desperate attempt on the proxy class itself...
+			return targetType.getMethod(method.getName(), method.getParameterTypes());
+		}
+		catch (NoSuchMethodException ex) {
+			throw new IllegalStateException(String.format(
+					"Need to invoke method '%s' declared on target class '%s', " +
+					"but not found in any interface(s) of the exposed proxy type. " +
+					"Either pull the method up to an interface or switch to CGLIB " +
+					"proxies by enforcing proxy-target-class mode in your configuration.",
+					method.getName(), method.getDeclaringClass().getSimpleName()));
+		}
+	}
+
+
+	/**
+	 * A callback interface for metadata lookup on a given method.
+	 * @param <T> the type of metadata returned
+	 */
+	public interface MetadataLookup<T> {
+
+		/**
+		 * Perform a lookup on the given method and return associated metadata, if any.
+		 * @param method the method to inspect
+		 * @return non-null metadata to be associated with a method if there is a match,
+		 * or {@code null} for no match
+		 */
+		T inspect(Method method);
+	}
+
+}