Add @ReplyTo/@ReplyToUser, remove deps on spring-web

Author: rstoyanchev

build.gradle

@@ -320,7 +320,6 @@ project("spring-messaging") {
 		compile(project(":spring-beans"))
 		compile(project(":spring-core"))
 		compile(project(":spring-context"))
-		optional(project(":spring-web")) // TODO: MediaType/HandlerMethod/EHMR
 		optional(project(":spring-websocket"))
 		optional("com.fasterxml.jackson.core:jackson-databind:2.2.0")
 		optional("org.projectreactor:reactor-core:1.0.0.BUILD-SNAPSHOT")

spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/ReplyTo.java

@@ -32,10 +32,9 @@
 @Documented
 public @interface ReplyTo {
 
-
 	/**
-	 * The destination value for the reply.
+	 * The destination for a message created from the return value of a method.
 	 */
-	String value();
+	String[] value() default {};
 
 }

spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/ExceptionHandlerMethodResolver.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2002-2013 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.messaging.handler.annotation.support;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.springframework.core.ExceptionDepthComparator;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.messaging.handler.annotation.MessageExceptionHandler;
+import org.springframework.messaging.handler.method.HandlerMethodSelector;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils.MethodFilter;
+
+
+/**
+ * Discovers annotated exception handling methods in a given class type, including all
+ * super types, and helps to resolve an Exception to a method that can handle it. The
+ * exception types supported by a given method can also be discovered from the method
+ * signature.
+ *
+ * @author Rossen Stoyanchev
+ * @since 4.0
+ */
+public class ExceptionHandlerMethodResolver {
+
+	private static final Method NO_METHOD_FOUND = ClassUtils.getMethodIfAvailable(System.class, "currentTimeMillis");
+
+	private final Map<Class<? extends Throwable>, Method> mappedMethods =
+			new ConcurrentHashMap<Class<? extends Throwable>, Method>(16);
+
+	private final Map<Class<? extends Throwable>, Method> exceptionLookupCache =
+			new ConcurrentHashMap<Class<? extends Throwable>, Method>(16);
+
+
+	/**
+	 * A constructor that finds {@link MessageExceptionHandler} methods in the given type.
+	 * @param handlerType the type to introspect
+	 */
+	public ExceptionHandlerMethodResolver(Class<?> handlerType) {
+		for (Method method : HandlerMethodSelector.selectMethods(handlerType, EXCEPTION_HANDLER_METHOD_FILTER)) {
+			for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
+				addExceptionMapping(exceptionType, method);
+			}
+		}
+	}
+
+	/**
+	 * Extract exception mappings from the {@code @ExceptionHandler} annotation
+	 * first and as a fall-back from the method signature.
+	 */
+	@SuppressWarnings("unchecked")
+	private List<Class<? extends Throwable>> detectExceptionMappings(Method method) {
+		List<Class<? extends Throwable>> result = new ArrayList<Class<? extends Throwable>>();
+
+		detectAnnotationExceptionMappings(method, result);
+
+		if (result.isEmpty()) {
+			for (Class<?> paramType : method.getParameterTypes()) {
+				if (Throwable.class.isAssignableFrom(paramType)) {
+					result.add((Class<? extends Throwable>) paramType);
+				}
+			}
+		}
+
+		Assert.notEmpty(result, "No exception types mapped to {" + method + "}");
+
+		return result;
+	}
+
+	protected void detectAnnotationExceptionMappings(Method method, List<Class<? extends Throwable>> result) {
+		MessageExceptionHandler annot = AnnotationUtils.findAnnotation(method, MessageExceptionHandler.class);
+		result.addAll(Arrays.asList(annot.value()));
+	}
+
+	private void addExceptionMapping(Class<? extends Throwable> exceptionType, Method method) {
+		Method oldMethod = this.mappedMethods.put(exceptionType, method);
+		if (oldMethod != null && !oldMethod.equals(method)) {
+			throw new IllegalStateException(
+					"Ambiguous @ExceptionHandler method mapped for [" + exceptionType + "]: {" +
+					oldMethod + ", " + method + "}.");
+		}
+	}
+
+	/**
+	 * Whether the contained type has any exception mappings.
+	 */
+	public boolean hasExceptionMappings() {
+		return (this.mappedMethods.size() > 0);
+	}
+
+	/**
+	 * Find a method to handle the given exception.
+	 * Use {@link ExceptionDepthComparator} if more than one match is found.
+	 * @param exception the exception
+	 * @return a method to handle the exception or {@code null}
+	 */
+	public Method resolveMethod(Exception exception) {
+		Class<? extends Exception> exceptionType = exception.getClass();
+		Method method = this.exceptionLookupCache.get(exceptionType);
+		if (method == null) {
+			method = getMappedMethod(exceptionType);
+			this.exceptionLookupCache.put(exceptionType, method != null ? method : NO_METHOD_FOUND);
+		}
+		return method != NO_METHOD_FOUND ? method : null;
+	}
+
+	/**
+	 * Return the method mapped to the given exception type or {@code null}.
+	 */
+	private Method getMappedMethod(Class<? extends Exception> exceptionType) {
+		List<Class<? extends Throwable>> matches = new ArrayList<Class<? extends Throwable>>();
+		for(Class<? extends Throwable> mappedException : this.mappedMethods.keySet()) {
+			if (mappedException.isAssignableFrom(exceptionType)) {
+				matches.add(mappedException);
+			}
+		}
+		if (!matches.isEmpty()) {
+			Collections.sort(matches, new ExceptionDepthComparator(exceptionType));
+			return mappedMethods.get(matches.get(0));
+		}
+		else {
+			return null;
+		}
+	}
+
+
+	/** A filter for selecting annotated exception handling methods. */
+	public final static MethodFilter EXCEPTION_HANDLER_METHOD_FILTER = new MethodFilter() {
+
+		@Override
+		public boolean matches(Method method) {
+			return AnnotationUtils.findAnnotation(method, MessageExceptionHandler.class) != null;
+		}
+	};
+
+}

spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/MessageBodyArgumentResolver.java renamed to spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/MessageBodyMethodArgumentResolver.java

@@ -19,21 +19,26 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.handler.annotation.MessageBody;
-import org.springframework.messaging.handler.method.MessageArgumentResolver;
+import org.springframework.messaging.handler.method.HandlerMethodArgumentResolver;
 import org.springframework.messaging.support.converter.MessageConverter;
 import org.springframework.util.Assert;
 
 
 /**
+ * TODO
+ *
+ * <p>This {@link HandlerMethodArgumentResolver} should be ordered last as it supports all
+ * types and does not require the {@link MessageBody} annotation.
+ *
  * @author Rossen Stoyanchev
  * @since 4.0
  */
-public class MessageBodyArgumentResolver implements MessageArgumentResolver {
+public class MessageBodyMethodArgumentResolver implements HandlerMethodArgumentResolver {
 
 	private final MessageConverter<?> converter;
 
 
-	public MessageBodyArgumentResolver(MessageConverter<?> converter) {
+	public MessageBodyMethodArgumentResolver(MessageConverter<?> converter) {
 		Assert.notNull(converter, "converter is required");
 		this.converter = converter;
 	}