Java MessageListenerAdapter类代码示例

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Bean
public DefaultMessageListenerContainer responder() {
	DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
	container.setConnectionFactory(connectionFactory());
	container.setDestinationName("test.out");
	MessageListenerAdapter adapter = new MessageListenerAdapter(new Object() {

		@SuppressWarnings("unused")
		public String handleMessage(String in) {
			return in.toUpperCase();
		}

	});
	container.setMessageListener(adapter);
	return container;
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void testJcaContainerConfiguration() throws Exception {
	Map<String, JmsMessageEndpointManager> containers = context.getBeansOfType(JmsMessageEndpointManager.class);

	assertTrue("listener3 not found", containers.containsKey("listener3"));
	JmsMessageEndpointManager listener3 = containers.get("listener3");
	assertEquals("Wrong resource adapter",
			context.getBean("testResourceAdapter"), listener3.getResourceAdapter());
	assertEquals("Wrong activation spec factory", context.getBean("testActivationSpecFactory"),
			new DirectFieldAccessor(listener3).getPropertyValue("activationSpecFactory"));


	Object endpointFactory = new DirectFieldAccessor(listener3).getPropertyValue("endpointFactory");
	Object messageListener = new DirectFieldAccessor(endpointFactory).getPropertyValue("messageListener");
	assertEquals("Wrong message listener", MessageListenerAdapter.class, messageListener.getClass());
	MessageListenerAdapter adapter = (MessageListenerAdapter) messageListener;
	DirectFieldAccessor adapterFieldAccessor = new DirectFieldAccessor(adapter);
	assertEquals("Message converter not set properly", context.getBean("testMessageConverter"),
			adapterFieldAccessor.getPropertyValue("messageConverter"));
	assertEquals("Wrong delegate", context.getBean("testBean1"),
			adapterFieldAccessor.getPropertyValue("delegate"));
	assertEquals("Wrong method name", "setName",
			adapterFieldAccessor.getPropertyValue("defaultListenerMethod"));
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void setupJmsMessageContainerFullConfig() {
	DefaultMessageListenerContainer container = new DefaultMessageListenerContainer();
	MessageListener messageListener = new MessageListenerAdapter();
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setDestination("myQueue");
	endpoint.setSelector("foo = 'bar'");
	endpoint.setSubscription("mySubscription");
	endpoint.setConcurrency("5-10");
	endpoint.setMessageListener(messageListener);

	endpoint.setupListenerContainer(container);
	assertEquals("myQueue", container.getDestinationName());
	assertEquals("foo = 'bar'", container.getMessageSelector());
	assertEquals("mySubscription", container.getSubscriptionName());
	assertEquals(5, container.getConcurrentConsumers());
	assertEquals(10, container.getMaxConcurrentConsumers());
	assertEquals(messageListener, container.getMessageListener());
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void setupMessageContainerUnsupportedContainer() {
	MessageListenerContainer container = mock(MessageListenerContainer.class);
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setMessageListener(new MessageListenerAdapter());

	thrown.expect(IllegalArgumentException.class);
	endpoint.setupListenerContainer(container);
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void createSimpleContainer() {
	SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
	setDefaultJmsConfig(factory);
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();

	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");

	SimpleMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertDefaultJmsConfig(container);
	assertEquals(messageListener, container.getMessageListener());
	assertEquals("myQueue", container.getDestinationName());
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void createJmsContainerFullConfig() {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	setDefaultJmsConfig(factory);
	factory.setCacheLevel(DefaultMessageListenerContainer.CACHE_CONSUMER);
	factory.setConcurrency("3-10");
	factory.setMaxMessagesPerTask(5);

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertDefaultJmsConfig(container);
	assertEquals(DefaultMessageListenerContainer.CACHE_CONSUMER, container.getCacheLevel());
	assertEquals(3, container.getConcurrentConsumers());
	assertEquals(10, container.getMaxConcurrentConsumers());
	assertEquals(5, container.getMaxMessagesPerTask());

	assertEquals(messageListener, container.getMessageListener());
	assertEquals("myQueue", container.getDestinationName());
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void createJcaContainerFullConfig() {
	DefaultJcaListenerContainerFactory factory = new DefaultJcaListenerContainerFactory();
	setDefaultJcaConfig(factory);
	factory.setConcurrency("10");

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	JmsMessageEndpointManager container = factory.createListenerContainer(endpoint);

	assertDefaultJcaConfig(container);
	assertEquals(10, container.getActivationSpecConfig().getMaxConcurrency());
	assertEquals(messageListener, container.getMessageListener());
	assertEquals("myQueue", container.getActivationSpecConfig().getDestinationName());
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
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 MessageListenerAdapter(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));
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
public void startListener() {
    MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter();
    messageListenerAdapter.setDelegate(this);
    messageListenerAdapter.setMessageConverter(mqMessageConverter);

    DefaultMessageListenerContainer mqListener = new DefaultMessageListenerContainer();
    mqListener.setConnectionFactory(mqConnectionFactory.getFactory());
    mqListener.setDestinationName(appConfig.getMqQueueName());
    mqListener.setMessageListener(messageListenerAdapter);
    mqListener.setConcurrency("4-8");
    mqListener.setSessionTransacted(true);

    mqListener.initialize();
    mqListener.start();
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void setupJcaMessageContainerFullConfig() {
	JmsMessageEndpointManager container = new JmsMessageEndpointManager();
	MessageListener messageListener = new MessageListenerAdapter();
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setDestination("myQueue");
	endpoint.setSelector("foo = 'bar'");
	endpoint.setSubscription("mySubscription");
	endpoint.setConcurrency("10");
	endpoint.setMessageListener(messageListener);

	endpoint.setupListenerContainer(container);
	JmsActivationSpecConfig config = container.getActivationSpecConfig();
	assertEquals("myQueue", config.getDestinationName());
	assertEquals("foo = 'bar'", config.getMessageSelector());
	assertEquals("mySubscription", config.getSubscriptionName());
	assertEquals(10, config.getMaxConcurrency());
	assertEquals(messageListener, container.getMessageListener());
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void createListener() {
	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	assertSame(messageListener, endpoint.createMessageListener(container));
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void jcaExclusiveProperties() {
	DefaultJcaListenerContainerFactory factory = new DefaultJcaListenerContainerFactory();
	factory.setDestinationResolver(destinationResolver);
	factory.setActivationSpecFactory(new StubJmsActivationSpecFactory());

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	endpoint.setMessageListener(new MessageListenerAdapter());
	thrown.expect(IllegalStateException.class);
	factory.createListenerContainer(endpoint);
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Test
public void backOffOverridesRecoveryInterval() {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	BackOff backOff = new FixedBackOff();
	factory.setBackOff(backOff);
	factory.setRecoveryInterval(2000L);

	SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
	MessageListener messageListener = new MessageListenerAdapter();
	endpoint.setMessageListener(messageListener);
	endpoint.setDestination("myQueue");
	DefaultMessageListenerContainer container = factory.createListenerContainer(endpoint);

	assertSame(backOff, new DirectFieldAccessor(container).getPropertyValue("backOff"));
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
@Bean
public MessageListenerAdapter adapter(AuditLogger auditLogger) {
    MessageListenerAdapter messageListener
            = new MessageListenerAdapter(auditLogger);
    messageListener.setDefaultListenerMethod("log");
    return messageListener;
}
 

import org.springframework.jms.listener.adapter.MessageListenerAdapter; //导入依赖的package包/类
/**
 * Message listener adapter to listen on new messages
 *
 * @param receiver
 * @return MessageListenerAdapter
 */
@Bean
MessageListenerAdapter adapter(final Receiver receiver) {
  MessageListenerAdapter messageListener = new MessageListenerAdapter(receiver);
  messageListener.setDefaultListenerMethod("receiveMessage");
  return messageListener;
}