@Test public void testWithMessageDelegate() throws Exception { TextMessage textMessage = mock(TextMessage.class); MessageDelegate delegate = mock(MessageDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); // we DON'T want the default SimpleMessageConversion happening... adapter.setMessageConverter(null); adapter.onMessage(textMessage); verify(delegate).handleMessage(textMessage); }
@Test public void testThatTheDefaultMessageHandlingMethodNameIsTheConstantDefault() throws Exception { MessageListenerAdapter adapter = new MessageListenerAdapter(); assertEquals(MessageListenerAdapter.ORIGINAL_DEFAULT_LISTENER_METHOD, adapter.getDefaultListenerMethod()); }
Object delegate = getDelegate(); if (delegate != this) { if (delegate instanceof SessionAwareMessageListener) { Object convertedMessage = extractMessage(message); String methodName = getListenerMethodName(message, convertedMessage); Object[] listenerArguments = buildListenerArguments(convertedMessage); Object result = invokeListenerMethod(methodName, listenerArguments); if (result != null) { handleResult(result, message, session);
@Test public void testThatWhenNoDelegateIsSuppliedTheDelegateIsAssumedToBeTheMessageListenerAdapterItself() throws Exception { MessageListenerAdapter adapter = new MessageListenerAdapter(); assertSame(adapter, adapter.getDelegate()); }
@Bean public MessageListener simpleMessageListener() { return new MessageListenerAdapter(); } }
MessageConverter messageConverter) MessageListenerAdapter adapter=new MessageListenerAdapter(handler); adapter.setDefaultListenerMethod(handlerMethod); adapter.setMessageConverter(messageConverter); if (replyDstName!=null) { if (isReplyDstTopic) { adapter.setDefaultResponseTopicName(replyDstName); } else { adapter.setDefaultResponseQueueName(replyDstName);
@Test public void testThatAnExceptionThrownFromTheHandlingMethodIsSimplySwallowedByDefault() throws Exception { final IllegalArgumentException exception = new IllegalArgumentException(); TextMessage textMessage = mock(TextMessage.class); MessageDelegate delegate = mock(MessageDelegate.class); willThrow(exception).given(delegate).handleMessage(textMessage); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected void handleListenerException(Throwable ex) { assertNotNull("The Throwable passed to the handleListenerException(..) method must never be null.", ex); assertTrue("The Throwable passed to the handleListenerException(..) method must be of type [ListenerExecutionFailedException].", ex instanceof ListenerExecutionFailedException); ListenerExecutionFailedException lefx = (ListenerExecutionFailedException) ex; Throwable cause = lefx.getCause(); assertNotNull("The cause of a ListenerExecutionFailedException must be preserved.", cause); assertSame(exception, cause); } }; // we DON'T want the default SimpleMessageConversion happening... adapter.setMessageConverter(null); adapter.onMessage(textMessage); }
@Test public void testWithMessageContentsDelegateForTextMessage() throws Exception { TextMessage textMessage = mock(TextMessage.class); // TextMessage contents must be unwrapped... given(textMessage.getText()).willReturn(TEXT); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(textMessage); verify(delegate).handleMessage(TEXT); }
MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(); messageListenerAdapter.setMessageConverter(converterToSet); messageListenerAdapter.setDelegate(this); this.messageListenerContainer.setConnectionFactory(this.connectionFactory); this.messageListenerContainer.setMessageListener(messageListenerAdapter);
@Override public String getSubscriptionName() { Object delegate = getDelegate(); if (delegate != this && delegate instanceof SubscriptionNameProvider) { return ((SubscriptionNameProvider) delegate).getSubscriptionName(); } else { return delegate.getClass().getName(); } }
@Test public void testThatTheDefaultMessageConverterisIndeedTheSimpleMessageConverter() throws Exception { MessageListenerAdapter adapter = new MessageListenerAdapter(); assertNotNull("The default [MessageConverter] must never be null.", adapter.getMessageConverter()); assertTrue("The default [MessageConverter] must be of the type [SimpleMessageConverter]", adapter.getMessageConverter() instanceof SimpleMessageConverter); }
/** * Determine the name of the listener method that is supposed to * handle the given message. * <p>The default implementation simply returns the configured * default listener method, if any. * @param originalMessage the JMS request message * @param extractedMessage the converted JMS request message, * to be passed into the listener method as argument * @return the name of the listener method (never {@code null}) * @throws JMSException if thrown by JMS API methods * @see #setDefaultListenerMethod */ protected String getListenerMethodName(Message originalMessage, Object extractedMessage) throws JMSException { return getDefaultListenerMethod(); }
private void registerListenerEndpoint(JmsListenerEndpointRegistrar aRegistrar, String aQueueName, int aConcurrency, Object aDelegate, String aMethodName) { logger.info("Registring JMS Listener: {} -> {}:{}", aQueueName, aDelegate.getClass().getName(), aMethodName); MessageListenerAdapter messageListener = new NoReplyMessageListenerAdapter(aDelegate); messageListener.setMessageConverter(jacksonJmsMessageConverter(objectMapper)); messageListener.setDefaultListenerMethod(aMethodName); SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint(); endpoint.setId(aQueueName+"Endpoint"); endpoint.setDestination(aQueueName); endpoint.setMessageListener(messageListener); aRegistrar.registerEndpoint(endpoint,createContainerFactory(aConcurrency)); }
boolean acceptMessagesWhileStopping = mqPropertyEntity.getBoolean(ThunderConstant.MQ_ACCEPT_MESSAGES_WHILE_STOPPING_ATTRIBUTE_NAME); MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(); messageListenerAdapter.setDelegate(messageListener);
/** * Initialize the default implementations for the adapter's strategies. * @see #setMessageConverter * @see org.springframework.jms.support.converter.SimpleMessageConverter */ protected void initDefaultStrategies() { setMessageConverter(new SimpleMessageConverter()); }
/** * Create a new {@link MessageListenerAdapter} for the given delegate. * @param delegate the delegate object */ public MessageListenerAdapter(Object delegate) { initDefaultStrategies(); setDelegate(delegate); }
private JmsListenerEndpoint createDummyEndpoint() { SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint(); endpoint.setMessageListener(new MessageListenerAdapter()); endpoint.setDestination("testQueue"); return endpoint; }
@Test public void testWithResponsiveMessageDelegateWhenReturnTypeIsNotAJMSMessageAndNoMessageConverterIsSupplied() throws Exception { final TextMessage sentTextMessage = mock(TextMessage.class); final Session session = mock(Session.class); ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class); given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT); final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) { @Override protected Object extractMessage(Message message) { return message; } }; adapter.setMessageConverter(null); try { adapter.onMessage(sentTextMessage, session); fail("expected CouldNotSendReplyException with MessageConversionException"); } catch (ReplyFailureException ex) { assertEquals(MessageConversionException.class, ex.getCause().getClass()); } }
@Test public void testWithMessageContentsDelegateForObjectMessage() throws Exception { ObjectMessage objectMessage = mock(ObjectMessage.class); given(objectMessage.getObject()).willReturn(NUMBER); MessageContentsDelegate delegate = mock(MessageContentsDelegate.class); MessageListenerAdapter adapter = new MessageListenerAdapter(delegate); adapter.onMessage(objectMessage); verify(delegate).handleMessage(NUMBER); }
try { MethodInvoker methodInvoker = new MethodInvoker(); methodInvoker.setTargetObject(getDelegate()); methodInvoker.setTargetMethod(methodName); methodInvoker.setArguments(arguments);