Move JmsHandlerMethodFactory to spring-messaging

This commit moves JmsHandlerMethodFactory and its default
implementation to the messaging abstraction. Working on a similar
support for AMQP revealed that this factory has nothing that is JMS
specific and is exactly identical in the case of AMQP.

Issue: SPR-12053

spring-jms/src/main/java/org/springframework/jms/annotation/EnableJms.java

@@ -112,10 +112,10 @@ import org.springframework.context.annotation.Import;
  *     // process incoming message
  * }</pre>
  *
- * These features are abstracted by the {@link org.springframework.jms.config.JmsHandlerMethodFactory
- * JmsHandlerMethodFactory} that is responsible to build the necessary invoker to process
- * the annotated method. By default, {@link org.springframework.jms.config.DefaultJmsHandlerMethodFactory
- * DefaultJmsHandlerMethodFactory} is used.
+ * These features are abstracted by the {@link org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory
+ * MessageHandlerMethodFactory} that is responsible to build the necessary invoker to process
+ * the annotated method. By default, {@link org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory
+ * DefaultMessageHandlerMethodFactory} is used.
  *
  * <p>When more control is desired, a {@code @Configuration} class may implement
  * {@link JmsListenerConfigurer}. This allows access to the underlying
@@ -172,7 +172,7 @@ import org.springframework.context.annotation.Import;
  *     &#064;Override
  *     public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
  *         registrar.setEndpointRegistry(myJmsListenerEndpointRegistry());
- *         registrar.setJmsHandlerMethodFactory(myJmsHandlerMethodFactory);
+ *         registrar.setMessageHandlerMethodFactory(myJmsHandlerMethodFactory);
  *     }
  *
  *     &#064;Bean
@@ -206,7 +206,7 @@ import org.springframework.context.annotation.Import;
  *     </bean>
  *
  *     <bean id="myJmsHandlerMethodFactory"
- *           class="org.springframework.jms.config.DefaultJmsHandlerMethodFactory">
+ *           class="org.springframework.messaging.handler.support.DefaultJmsHandlerMethodFactory">
  *         <property name="validator" ref="myValidator"/>
  *     </bean>
  *

spring-jms/src/main/java/org/springframework/jms/annotation/JmsListenerAnnotationBeanPostProcessor.java

@@ -31,13 +31,13 @@ import org.springframework.beans.factory.SmartInitializingSingleton;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.AnnotationUtils;
-import org.springframework.jms.config.DefaultJmsHandlerMethodFactory;
-import org.springframework.jms.config.JmsHandlerMethodFactory;
 import org.springframework.jms.config.JmsListenerConfigUtils;
 import org.springframework.jms.config.JmsListenerContainerFactory;
 import org.springframework.jms.config.JmsListenerEndpointRegistrar;
 import org.springframework.jms.config.JmsListenerEndpointRegistry;
 import org.springframework.jms.config.MethodJmsListenerEndpoint;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
+import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;
 import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
 import org.springframework.util.Assert;
 import org.springframework.util.ReflectionUtils;
@@ -86,7 +86,7 @@ public class JmsListenerAnnotationBeanPostProcessor
 
 	private BeanFactory beanFactory;
 
-	private final JmsHandlerMethodFactoryAdapter jmsHandlerMethodFactory = new JmsHandlerMethodFactoryAdapter();
+	private final MessageHandlerMethodFactoryAdapter messageHandlerMethodFactory = new MessageHandlerMethodFactoryAdapter();
 
 	private final JmsListenerEndpointRegistrar registrar = new JmsListenerEndpointRegistrar();
 
@@ -115,15 +115,15 @@ public class JmsListenerAnnotationBeanPostProcessor
 	}
 
 	/**
-	 * Set the {@link JmsHandlerMethodFactory} to use to configure the message
+	 * Set the {@link MessageHandlerMethodFactory} to use to configure the message
 	 * listener responsible to serve an endpoint detected by this processor.
-	 * <p>By default, {@link DefaultJmsHandlerMethodFactory} is used and it
+	 * <p>By default, {@link DefaultMessageHandlerMethodFactory} is used and it
 	 * can be configured further to support additional method arguments
 	 * or to customize conversion and validation support. See
-	 * {@link DefaultJmsHandlerMethodFactory} Javadoc for more details.
+	 * {@link DefaultMessageHandlerMethodFactory} Javadoc for more details.
 	 */
-	public void setJmsHandlerMethodFactory(JmsHandlerMethodFactory jmsHandlerMethodFactory) {
-		this.jmsHandlerMethodFactory.setJmsHandlerMethodFactory(jmsHandlerMethodFactory);
+	public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory) {
+		this.messageHandlerMethodFactory.setMessageHandlerMethodFactory(messageHandlerMethodFactory);
 	}
 
 	/**
@@ -163,9 +163,9 @@ public class JmsListenerAnnotationBeanPostProcessor
 		}
 
 		// Set the custom handler method factory once resolved by the configurer
-		JmsHandlerMethodFactory handlerMethodFactory = this.registrar.getJmsHandlerMethodFactory();
+		MessageHandlerMethodFactory handlerMethodFactory = this.registrar.getMessageHandlerMethodFactory();
 		if (handlerMethodFactory != null) {
-			this.jmsHandlerMethodFactory.setJmsHandlerMethodFactory(handlerMethodFactory);
+			this.messageHandlerMethodFactory.setMessageHandlerMethodFactory(handlerMethodFactory);
 		}
 
 		// Actually register all listeners
@@ -216,7 +216,7 @@ public class JmsListenerAnnotationBeanPostProcessor
 		MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
 		endpoint.setBean(bean);
 		endpoint.setMethod(method);
-		endpoint.setJmsHandlerMethodFactory(this.jmsHandlerMethodFactory);
+		endpoint.setMessageHandlerMethodFactory(this.messageHandlerMethodFactory);
 		endpoint.setId(getEndpointId(jmsListener));
 		endpoint.setDestination(jmsListener.destination());
 		if (StringUtils.hasText(jmsListener.selector())) {
@@ -257,33 +257,33 @@ public class JmsListenerAnnotationBeanPostProcessor
 
 
 	/**
-	 * An {@link JmsHandlerMethodFactory} adapter that offers a configurable underlying
+	 * A {@link MessageHandlerMethodFactory} adapter that offers a configurable underlying
 	 * instance to use. Useful if the factory to use is determined once the endpoints
 	 * have been registered but not created yet.
-	 * @see JmsListenerEndpointRegistrar#setJmsHandlerMethodFactory(JmsHandlerMethodFactory)
+	 * @see JmsListenerEndpointRegistrar#setMessageHandlerMethodFactory
 	 */
-	private class JmsHandlerMethodFactoryAdapter implements JmsHandlerMethodFactory {
+	private class MessageHandlerMethodFactoryAdapter implements MessageHandlerMethodFactory {
 
-		private JmsHandlerMethodFactory jmsHandlerMethodFactory;
+		private MessageHandlerMethodFactory messageHandlerMethodFactory;
 
-		public void setJmsHandlerMethodFactory(JmsHandlerMethodFactory jmsHandlerMethodFactory) {
-			this.jmsHandlerMethodFactory = jmsHandlerMethodFactory;
+		public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory) {
+			this.messageHandlerMethodFactory = messageHandlerMethodFactory;
 		}
 
 		@Override
 		public InvocableHandlerMethod createInvocableHandlerMethod(Object bean, Method method) {
-			return getJmsHandlerMethodFactory().createInvocableHandlerMethod(bean, method);
+			return getMessageHandlerMethodFactory().createInvocableHandlerMethod(bean, method);
 		}
 
-		private JmsHandlerMethodFactory getJmsHandlerMethodFactory() {
-			if (this.jmsHandlerMethodFactory == null) {
-				this.jmsHandlerMethodFactory = createDefaultJmsHandlerMethodFactory();
+		private MessageHandlerMethodFactory getMessageHandlerMethodFactory() {
+			if (this.messageHandlerMethodFactory == null) {
+				this.messageHandlerMethodFactory = createDefaultJmsHandlerMethodFactory();
 			}
-			return this.jmsHandlerMethodFactory;
+			return this.messageHandlerMethodFactory;
 		}
 
-		private JmsHandlerMethodFactory createDefaultJmsHandlerMethodFactory() {
-			DefaultJmsHandlerMethodFactory defaultFactory = new DefaultJmsHandlerMethodFactory();
+		private MessageHandlerMethodFactory createDefaultJmsHandlerMethodFactory() {
+			DefaultMessageHandlerMethodFactory defaultFactory = new DefaultMessageHandlerMethodFactory();
 			defaultFactory.setBeanFactory(beanFactory);
 			defaultFactory.afterPropertiesSet();
 			return defaultFactory;

spring-jms/src/main/java/org/springframework/jms/config/AnnotationDrivenJmsBeanDefinitionParser.java

@@ -70,7 +70,7 @@ class AnnotationDrivenJmsBeanDefinitionParser implements BeanDefinitionParser {
 
 			String handlerMethodFactory = element.getAttribute("handler-method-factory");
 			if (StringUtils.hasText(handlerMethodFactory)) {
-				builder.addPropertyReference("jmsHandlerMethodFactory", handlerMethodFactory);
+				builder.addPropertyReference("messageHandlerMethodFactory", handlerMethodFactory);
 			}
 
 			registerInfrastructureBean(parserContext, builder,

spring-jms/src/main/java/org/springframework/jms/config/JmsListenerEndpointRegistrar.java

@@ -22,6 +22,8 @@ import java.util.List;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
+import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;
 import org.springframework.util.Assert;
 
 /**
@@ -37,7 +39,7 @@ public class JmsListenerEndpointRegistrar implements BeanFactoryAware, Initializ
 
 	private JmsListenerEndpointRegistry endpointRegistry;
 
-	private JmsHandlerMethodFactory jmsHandlerMethodFactory;
+	private MessageHandlerMethodFactory messageHandlerMethodFactory;
 
 	private JmsListenerContainerFactory<?> containerFactory;
 
@@ -65,22 +67,22 @@ public class JmsListenerEndpointRegistrar implements BeanFactoryAware, Initializ
 	}
 
 	/**
-	 * Set the {@link JmsHandlerMethodFactory} to use to configure the message
+	 * Set the {@link MessageHandlerMethodFactory} to use to configure the message
 	 * listener responsible to serve an endpoint detected by this processor.
-	 * <p>By default, {@link DefaultJmsHandlerMethodFactory} is used and it
+	 * <p>By default, {@link DefaultMessageHandlerMethodFactory} is used and it
 	 * can be configured further to support additional method arguments
 	 * or to customize conversion and validation support. See
-	 * {@link DefaultJmsHandlerMethodFactory} javadoc for more details.
+	 * {@link DefaultMessageHandlerMethodFactory} javadoc for more details.
 	 */
-	public void setJmsHandlerMethodFactory(JmsHandlerMethodFactory jmsHandlerMethodFactory) {
-		this.jmsHandlerMethodFactory = jmsHandlerMethodFactory;
+	public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory) {
+		this.messageHandlerMethodFactory = messageHandlerMethodFactory;
 	}
 
 	/**
-	 * Return the custom {@link JmsHandlerMethodFactory} to use, if any.
+	 * Return the custom {@link MessageHandlerMethodFactory} to use, if any.
 	 */
-	public JmsHandlerMethodFactory getJmsHandlerMethodFactory() {
-		return this.jmsHandlerMethodFactory;
+	public MessageHandlerMethodFactory getMessageHandlerMethodFactory() {
+		return this.messageHandlerMethodFactory;
 	}
 
 	/**

spring-jms/src/main/java/org/springframework/jms/config/MethodJmsListenerEndpoint.java

@@ -25,6 +25,7 @@ import org.springframework.jms.listener.adapter.MessagingMessageListenerAdapter;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.messaging.handler.annotation.SendTo;
 import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
+import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -41,7 +42,7 @@ public class MethodJmsListenerEndpoint extends AbstractJmsListenerEndpoint {
 
 	private Method method;
 
-	private JmsHandlerMethodFactory jmsHandlerMethodFactory;
+	private MessageHandlerMethodFactory messageHandlerMethodFactory;
 
 
 	/**
@@ -67,22 +68,22 @@ public class MethodJmsListenerEndpoint extends AbstractJmsListenerEndpoint {
 	}
 
 	/**
-	 * Set the {@link JmsHandlerMethodFactory} to use to build the
+	 * Set the {@link MessageHandlerMethodFactory} to use to build the
 	 * {@link InvocableHandlerMethod} responsible to manage the invocation
 	 * of this endpoint.
 	 */
-	public void setJmsHandlerMethodFactory(JmsHandlerMethodFactory jmsHandlerMethodFactory) {
-		this.jmsHandlerMethodFactory = jmsHandlerMethodFactory;
+	public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory) {
+		this.messageHandlerMethodFactory = messageHandlerMethodFactory;
 	}
 
 
 	@Override
 	protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
-		Assert.state(this.jmsHandlerMethodFactory != null,
-				"Could not create message listener - message listener factory not set");
+		Assert.state(this.messageHandlerMethodFactory != null,
+				"Could not create message listener - MessageHandlerMethodFactory not set");
 		MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
 		InvocableHandlerMethod invocableHandlerMethod =
-				this.jmsHandlerMethodFactory.createInvocableHandlerMethod(getBean(), getMethod());
+				this.messageHandlerMethodFactory.createInvocableHandlerMethod(getBean(), getMethod());
 		messageListener.setHandlerMethod(invocableHandlerMethod);
 		String responseDestination = getDefaultResponseDestination();
 		if (StringUtils.hasText(responseDestination)) {

spring-jms/src/main/resources/org/springframework/jms/config/spring-jms-4.1.xsd

@@ -63,16 +63,16 @@
 			<xsd:attribute name="handler-method-factory" type="xsd:string" use="optional">
 				<xsd:annotation>
 					<xsd:documentation><![CDATA[
-	Specifies a custom org.springframework.jms.config.JmsHandlerMethodFactory instance to
-	use to configure the message listener responsible to serve an endpoint detected by this
-	processor. By default, DefaultJmsHandlerMethodFactory is used and it can be configured
+	Specifies a custom org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory
+	instance to	use to configure the message listener responsible to serve an endpoint detected by this
+	processor. By default, DefaultMessageHandlerMethodFactory is used and it can be configured
 	further to support additional method arguments or to customize conversion and validation
-	support. See org.springframework.jms.config.DefaultJmsHandlerMethodFactory Javadoc for
-	more details.
+	support. See org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory
+	Javadoc for more details.
 					]]></xsd:documentation>
 					<xsd:appinfo>
 						<tool:annotation kind="ref">
-							<tool:expected-type type="org.springframework.jms.config.JmsHandlerMethodFactory"/>
+							<tool:expected-type type="org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory"/>
 						</tool:annotation>
 					</xsd:appinfo>
 				</xsd:annotation>

spring-jms/src/test/java/org/springframework/jms/annotation/AbstractJmsAnnotationDrivenTests.java

@@ -184,7 +184,7 @@ public abstract class AbstractJmsAnnotationDrivenTests {
 
 	/**
 	 * Test for {@link ValidationBean} with a validator ({@link TestValidator}) specified
-	 * in a custom {@link org.springframework.jms.config.DefaultJmsHandlerMethodFactory}.
+	 * in a custom {@link org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory}.
 	 *
 	 * The test should throw a {@link org.springframework.jms.listener.adapter.ListenerExecutionFailedException}
 	 */

spring-jms/src/test/java/org/springframework/jms/annotation/EnableJmsTests.java

@@ -25,14 +25,12 @@ import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
 import org.springframework.beans.factory.BeanCreationException;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.jms.config.DefaultJmsHandlerMethodFactory;
-import org.springframework.jms.config.JmsHandlerMethodFactory;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
+import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;
 import org.springframework.jms.config.JmsListenerContainerTestFactory;
 import org.springframework.jms.config.JmsListenerEndpointRegistrar;
 import org.springframework.jms.config.JmsListenerEndpointRegistry;
@@ -42,7 +40,6 @@ import org.springframework.jms.listener.adapter.MessageListenerAdapter;
 import org.springframework.messaging.handler.annotation.support.MethodArgumentNotValidException;
 
 /**
- *
  * @author Stephane Nicoll
  */
 public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
@@ -202,12 +199,12 @@ public class EnableJmsTests extends AbstractJmsAnnotationDrivenTests {
 
 		@Override
 		public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
-			registrar.setJmsHandlerMethodFactory(jmsHandlerMethodFactory());
+			registrar.setMessageHandlerMethodFactory(customMessageHandlerMethodFactory());
 		}
 
 		@Bean
-		public JmsHandlerMethodFactory jmsHandlerMethodFactory() {
-			DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory();
+		public MessageHandlerMethodFactory customMessageHandlerMethodFactory() {
+			DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
 			factory.setValidator(new TestValidator());
 			return factory;
 		}

spring-jms/src/test/java/org/springframework/jms/config/JmsListenerContainerFactoryIntegrationTests.java

@@ -36,6 +36,7 @@ import org.springframework.jms.listener.SessionAwareMessageListener;
 import org.springframework.jms.support.converter.MessageConversionException;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.messaging.handler.annotation.Payload;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
 import org.springframework.util.ReflectionUtils;
 
 import static org.junit.Assert.*;
@@ -48,7 +49,7 @@ public class JmsListenerContainerFactoryIntegrationTests {
 
 	private final DefaultJmsListenerContainerFactory containerFactory = new DefaultJmsListenerContainerFactory();
 
-	private final DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory();
+	private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
 
 	private final JmsEndpointSampleBean sample = new JmsEndpointSampleBean();
 
@@ -88,11 +89,11 @@ public class JmsListenerContainerFactoryIntegrationTests {
 
 
 	private MethodJmsListenerEndpoint createMethodJmsEndpoint(
-			DefaultJmsHandlerMethodFactory factory, Method method) {
+			DefaultMessageHandlerMethodFactory factory, Method method) {
 		MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
 		endpoint.setBean(sample);
 		endpoint.setMethod(method);
-		endpoint.setJmsHandlerMethodFactory(factory);
+		endpoint.setMessageHandlerMethodFactory(factory);
 		return endpoint;
 	}
 
@@ -107,7 +108,7 @@ public class JmsListenerContainerFactoryIntegrationTests {
 	}
 
 
-	private void initializeFactory(DefaultJmsHandlerMethodFactory factory) {
+	private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
 		factory.setBeanFactory(new StaticListableBeanFactory());
 		factory.afterPropertiesSet();
 	}

spring-jms/src/test/java/org/springframework/jms/config/MethodJmsListenerEndpointTests.java

@@ -55,6 +55,7 @@ import org.springframework.messaging.handler.annotation.Headers;
 import org.springframework.messaging.handler.annotation.Payload;
 import org.springframework.messaging.handler.annotation.SendTo;
 import org.springframework.messaging.handler.annotation.support.MethodArgumentTypeMismatchException;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.validation.Errors;
 import org.springframework.validation.Validator;
@@ -76,7 +77,7 @@ public class MethodJmsListenerEndpointTests {
 	@Rule
 	public final ExpectedException thrown = ExpectedException.none();
 
-	private final DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory();
+	private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
 
 	private final DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
 
@@ -103,7 +104,7 @@ public class MethodJmsListenerEndpointTests {
 		MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
 		endpoint.setBean(this);
 		endpoint.setMethod(getTestMethod());
-		endpoint.setJmsHandlerMethodFactory(factory);
+		endpoint.setMessageHandlerMethodFactory(factory);
 
 		assertNotNull(endpoint.createMessageListener(container));
 	}
@@ -304,7 +305,7 @@ public class MethodJmsListenerEndpointTests {
 	public void validatePayloadValid() throws JMSException {
 		String methodName = "validatePayload";
 
-		DefaultJmsHandlerMethodFactory customFactory = new DefaultJmsHandlerMethodFactory();
+		DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
 		customFactory.setValidator(testValidator("invalid value"));
 		initializeFactory(customFactory);
 
@@ -317,7 +318,7 @@ public class MethodJmsListenerEndpointTests {
 
 	@Test
 	public void validatePayloadInvalid() throws JMSException {
-		DefaultJmsHandlerMethodFactory customFactory = new DefaultJmsHandlerMethodFactory();
+		DefaultMessageHandlerMethodFactory customFactory = new DefaultMessageHandlerMethodFactory();
 		customFactory.setValidator(testValidator("invalid value"));
 
 		Method method = getListenerMethod("validatePayload", String.class);
@@ -353,16 +354,16 @@ public class MethodJmsListenerEndpointTests {
 	}
 
 	private MessagingMessageListenerAdapter createInstance(
-			DefaultJmsHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
+			DefaultMessageHandlerMethodFactory factory, Method method, MessageListenerContainer container) {
 		MethodJmsListenerEndpoint endpoint = new MethodJmsListenerEndpoint();
 		endpoint.setBean(sample);
 		endpoint.setMethod(method);
-		endpoint.setJmsHandlerMethodFactory(factory);
+		endpoint.setMessageHandlerMethodFactory(factory);
 		return endpoint.createMessageListener(container);
 	}
 
 	private MessagingMessageListenerAdapter createInstance(
-			DefaultJmsHandlerMethodFactory factory, Method method) {
+			DefaultMessageHandlerMethodFactory factory, Method method) {
 		return createInstance(factory, method, new SimpleMessageListenerContainer());
 	}
 
@@ -392,7 +393,7 @@ public class MethodJmsListenerEndpointTests {
 		assertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
 	}
 
-	private void initializeFactory(DefaultJmsHandlerMethodFactory factory) {
+	private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
 		factory.setBeanFactory(new StaticListableBeanFactory());
 		factory.afterPropertiesSet();
 	}

spring-jms/src/test/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapterTests.java

@@ -27,7 +27,7 @@ import org.junit.Test;
 
 import org.springframework.beans.factory.support.StaticListableBeanFactory;
 import org.springframework.jms.StubTextMessage;
-import org.springframework.jms.config.DefaultJmsHandlerMethodFactory;
+import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
 import org.springframework.jms.support.JmsHeaders;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.converter.MessageConversionException;
@@ -42,7 +42,7 @@ import static org.mockito.BDDMockito.*;
  */
 public class MessagingMessageListenerAdapterTests {
 
-	private final DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory();
+	private final DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
 
 	private final SampleBean sample = new SampleBean();
 
@@ -122,7 +122,7 @@ public class MessagingMessageListenerAdapterTests {
 		return adapter;
 	}
 
-	private void initializeFactory(DefaultJmsHandlerMethodFactory factory) {
+	private void initializeFactory(DefaultMessageHandlerMethodFactory factory) {
 		factory.setBeanFactory(new StaticListableBeanFactory());
 		factory.afterPropertiesSet();
 	}

spring-jms/src/test/resources/org/springframework/jms/annotation/annotation-driven-custom-handler-method-factory.xml

@@ -7,9 +7,9 @@
 	   http://www.springframework.org/schema/jms
 	   http://www.springframework.org/schema/jms/spring-jms-4.1.xsd">
 
-	<jms:annotation-driven handler-method-factory="jmsHandlerMethodFactory"/>
+	<jms:annotation-driven handler-method-factory="customMessageHandlerMethodFactory"/>
 
-	<bean id="jmsHandlerMethodFactory" class="org.springframework.jms.config.DefaultJmsHandlerMethodFactory">
+	<bean id="customMessageHandlerMethodFactory" class="org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory">
 		<property name="validator">
 			<bean class="org.springframework.jms.annotation.AbstractJmsAnnotationDrivenTests$TestValidator"/>
 		</property>

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.config;
+package org.springframework.messaging.handler.annotation.support;
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -28,10 +28,6 @@ import org.springframework.core.convert.ConversionService;
 import org.springframework.format.support.DefaultFormattingConversionService;
 import org.springframework.messaging.converter.GenericMessageConverter;
 import org.springframework.messaging.converter.MessageConverter;
-import org.springframework.messaging.handler.annotation.support.HeaderMethodArgumentResolver;
-import org.springframework.messaging.handler.annotation.support.HeadersMethodArgumentResolver;
-import org.springframework.messaging.handler.annotation.support.MessageMethodArgumentResolver;
-import org.springframework.messaging.handler.annotation.support.PayloadArgumentResolver;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolverComposite;
 import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
@@ -39,11 +35,11 @@ import org.springframework.validation.Errors;
 import org.springframework.validation.Validator;
 
 /**
- * The default {@link JmsHandlerMethodFactory} implementation creating an
+ * The default {@link MessageHandlerMethodFactory} implementation creating an
  * {@link InvocableHandlerMethod} with the necessary
  * {@link HandlerMethodArgumentResolver} instances to detect and process
- * all the use cases defined by {@link org.springframework.jms.annotation.JmsListener
- * JmsListener}.
+ * most of  the use cases defined by
+ * {@link org.springframework.messaging.handler.annotation.MessageMapping MessageMapping}
  *
  * <p>Extra method argument resolvers can be added to customize the method
  * signature that can be handled.
@@ -60,7 +56,7 @@ import org.springframework.validation.Validator;
  * @see #setValidator
  * @see #setCustomArgumentResolvers
  */
-public class DefaultJmsHandlerMethodFactory implements JmsHandlerMethodFactory, BeanFactoryAware, InitializingBean {
+public class DefaultMessageHandlerMethodFactory implements MessageHandlerMethodFactory, BeanFactoryAware, InitializingBean {
 
 	private ConversionService conversionService = new DefaultFormattingConversionService();
 

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.config;
+package org.springframework.messaging.handler.annotation.support;
 
 import java.lang.reflect.Method;
 
@@ -22,19 +22,22 @@ import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
 
 /**
  * A factory for {@link InvocableHandlerMethod} that is suitable to process
- * an incoming JMS message.
+ * an incoming {@link org.springframework.messaging.Message}
+ *
+ * <p>Typically used by listener endpoints that require a flexible method
+ * signature.
  *
  * @author Stephane Nicoll
  * @since 4.1
  */
-public interface JmsHandlerMethodFactory {
+public interface MessageHandlerMethodFactory {
 
 	/**
 	 * Create the {@link InvocableHandlerMethod} that is able to process the specified
-	 * JMS method endpoint.
+	 * method endpoint.
 	 * @param bean the bean instance
 	 * @param method the method to invoke
-	 * @return a JMS-specific {@link InvocableHandlerMethod} suitable for that method
+	 * @return an {@link InvocableHandlerMethod} suitable for that method
 	 */
 	InvocableHandlerMethod createInvocableHandlerMethod(Object bean, Method method);
 

spring-messaging/src/test/java/org/springframework/messaging/handler/annotation/support/DefaultMessageHandlerMethodFactoryTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.config;
+package org.springframework.messaging.handler.annotation.support;
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -24,6 +24,8 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 
+import javax.validation.Valid;
+
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -37,17 +39,20 @@ import org.springframework.messaging.Message;
 import org.springframework.messaging.converter.ByteArrayMessageConverter;
 import org.springframework.messaging.converter.MessageConversionException;
 import org.springframework.messaging.converter.MessageConverter;
+import org.springframework.messaging.handler.annotation.Payload;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.InvocableHandlerMethod;
 import org.springframework.messaging.support.MessageBuilder;
 import org.springframework.util.ReflectionUtils;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
 
 import static org.junit.Assert.*;
 
 /**
  * @author Stephane Nicoll
  */
-public class DefaultJmsHandlerMethodFactoryTests {
+public class DefaultMessageHandlerMethodFactoryTests {
 
 	@Rule
 	public final TestName name = new TestName();
@@ -59,7 +64,7 @@ public class DefaultJmsHandlerMethodFactoryTests {
 
 	@Test
 	public void customConversion() throws Exception {
-		DefaultJmsHandlerMethodFactory instance = createInstance();
+		DefaultMessageHandlerMethodFactory instance = createInstance();
 		GenericConversionService conversionService = new GenericConversionService();
 		conversionService.addConverter(SampleBean.class, String.class, new Converter<SampleBean, String>() {
 			@Override
@@ -79,7 +84,7 @@ public class DefaultJmsHandlerMethodFactoryTests {
 
 	@Test
 	public void customConversionServiceFailure() throws Exception {
-		DefaultJmsHandlerMethodFactory instance = createInstance();
+		DefaultMessageHandlerMethodFactory instance = createInstance();
 		GenericConversionService conversionService = new GenericConversionService();
 		assertFalse("conversion service should fail to convert payload",
 				conversionService.canConvert(Integer.class, String.class));
@@ -95,7 +100,7 @@ public class DefaultJmsHandlerMethodFactoryTests {
 
 	@Test
 	public void customMessageConverterFailure() throws Exception {
-		DefaultJmsHandlerMethodFactory instance = createInstance();
+		DefaultMessageHandlerMethodFactory instance = createInstance();
 		MessageConverter messageConverter = new ByteArrayMessageConverter();
 		instance.setMessageConverter(messageConverter);
 		instance.afterPropertiesSet();
@@ -109,7 +114,7 @@ public class DefaultJmsHandlerMethodFactoryTests {
 
 	@Test
 	public void customArgumentResolver() throws Exception {
-		DefaultJmsHandlerMethodFactory instance = createInstance();
+		DefaultMessageHandlerMethodFactory instance = createInstance();
 		List<HandlerMethodArgumentResolver> customResolvers = new ArrayList<HandlerMethodArgumentResolver>();
 		customResolvers.add(new CustomHandlerMethodArgumentResolver());
 		instance.setCustomArgumentResolvers(customResolvers);
@@ -124,7 +129,7 @@ public class DefaultJmsHandlerMethodFactoryTests {
 
 	@Test
 	public void overrideArgumentResolvers() throws Exception {
-		DefaultJmsHandlerMethodFactory instance = createInstance();
+		DefaultMessageHandlerMethodFactory instance = createInstance();
 		List<HandlerMethodArgumentResolver> customResolvers = new ArrayList<HandlerMethodArgumentResolver>();
 		customResolvers.add(new CustomHandlerMethodArgumentResolver());
 		instance.setArgumentResolvers(customResolvers);
@@ -147,18 +152,53 @@ public class DefaultJmsHandlerMethodFactoryTests {
 		invocableHandlerMethod2.invoke(message);
 	}
 
+	@Test
+	public void noValidationByDefault() throws Exception {
+		DefaultMessageHandlerMethodFactory instance = createInstance();
+		instance.afterPropertiesSet();
+
+		InvocableHandlerMethod invocableHandlerMethod =
+				createInvocableHandlerMethod(instance, "payloadValidation", String.class);
+		invocableHandlerMethod.invoke(MessageBuilder.withPayload("failure").build());
+		assertMethodInvocation(sample, "payloadValidation");
+	}
+
+	@Test
+	public void customValidation() throws Exception {
+		DefaultMessageHandlerMethodFactory instance = createInstance();
+		instance.setValidator(new Validator() {
+			@Override
+			public boolean supports(Class<?> clazz) {
+				return String.class.isAssignableFrom(clazz);
+			}
+			@Override
+			public void validate(Object target, Errors errors) {
+				String value = (String) target;
+				if ("failure".equals(value)) {
+					errors.reject("not a valid value");
+				}
+			}
+		});
+		instance.afterPropertiesSet();
+
+		InvocableHandlerMethod invocableHandlerMethod =
+				createInvocableHandlerMethod(instance, "payloadValidation", String.class);
+		thrown.expect(MethodArgumentNotValidException.class);
+		invocableHandlerMethod.invoke(MessageBuilder.withPayload("failure").build());
+	}
+
 
 	private void assertMethodInvocation(SampleBean bean, String methodName) {
 		assertTrue("Method " + methodName + " should have been invoked", bean.invocations.get(methodName));
 	}
 
 	private InvocableHandlerMethod createInvocableHandlerMethod(
-			DefaultJmsHandlerMethodFactory factory, String methodName, Class<?>... parameterTypes) {
+			DefaultMessageHandlerMethodFactory factory, String methodName, Class<?>... parameterTypes) {
 		return factory.createInvocableHandlerMethod(sample, getListenerMethod(methodName, parameterTypes));
 	}
 
-	private DefaultJmsHandlerMethodFactory createInstance() {
-		DefaultJmsHandlerMethodFactory factory = new DefaultJmsHandlerMethodFactory();
+	private DefaultMessageHandlerMethodFactory createInstance() {
+		DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
 		factory.setBeanFactory(new StaticListableBeanFactory());
 		return factory;
 	}
@@ -178,6 +218,10 @@ public class DefaultJmsHandlerMethodFactoryTests {
 			invocations.put("simpleString", true);
 		}
 
+		public void payloadValidation(@Payload @Valid String value) {
+			invocations.put("payloadValidation", true);
+		}
+
 		public void customArgumentResolver(Locale locale) {
 			invocations.put("customArgumentResolver", true);
 			assertEquals("Wrong value for locale", Locale.getDefault(), locale);
@@ -197,5 +241,4 @@ public class DefaultJmsHandlerMethodFactoryTests {
 			return Locale.getDefault();
 		}
 	}
-
 }