Java JmsListenerContainerFactory类代码示例

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> myFactory(ConnectionFactory connectionFactory,
		DefaultJmsListenerContainerFactoryConfigurer configurer) {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	configurer.configure(factory, connectionFactory);
	return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean(name = "queueListenerContainerFactory")
@ConditionalOnProperty(prefix = "spring.activemq", name = "broker-url")
public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ConnectionFactory activeMQConnectionFactory) {
    DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
    bean.setConnectionFactory(activeMQConnectionFactory);
    bean.setPubSubDomain(Boolean.FALSE);
    return bean;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Test
public void testJmsListenerContainerFactoryWithCustomSettings() {
	load(EnableJmsConfiguration.class, "spring.jms.listener.autoStartup=false",
			"spring.jms.listener.acknowledgeMode=client",
			"spring.jms.listener.concurrency=2",
			"spring.jms.listener.maxConcurrency=10");
	JmsListenerContainerFactory<?> jmsListenerContainerFactory = this.context.getBean(
			"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
	assertThat(jmsListenerContainerFactory.getClass())
			.isEqualTo(DefaultJmsListenerContainerFactory.class);
	DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
			.createListenerContainer(mock(JmsListenerEndpoint.class));
	assertThat(listenerContainer.isAutoStartup()).isFalse();
	assertThat(listenerContainer.getSessionAcknowledgeMode())
			.isEqualTo(Session.CLIENT_ACKNOWLEDGE);
	assertThat(listenerContainer.getConcurrentConsumers()).isEqualTo(2);
	assertThat(listenerContainer.getMaxConcurrentConsumers()).isEqualTo(10);
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Test
public void testCustomContainerFactoryWithConfigurer() {
	this.context = doLoad(
			new Class<?>[] { TestConfiguration9.class, EnableJmsConfiguration.class },
			"spring.jms.listener.autoStartup=false");
	assertThat(this.context.containsBean("jmsListenerContainerFactory")).isTrue();
	JmsListenerContainerFactory<?> jmsListenerContainerFactory = this.context.getBean(
			"customListenerContainerFactory", JmsListenerContainerFactory.class);
	assertThat(jmsListenerContainerFactory)
			.isInstanceOf(DefaultJmsListenerContainerFactory.class);
	DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
			.createListenerContainer(mock(JmsListenerEndpoint.class));
	assertThat(listenerContainer.getCacheLevel())
			.isEqualTo(DefaultMessageListenerContainer.CACHE_CONSUMER);
	assertThat(listenerContainer.isAutoStartup()).isFalse();
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Test
public void testJmsListenerContainerFactoryWithCustomSettings() {
	load(EnableJmsConfiguration.class, "spring.jms.listener.autoStartup=false",
			"spring.jms.listener.acknowledgeMode=client",
			"spring.jms.listener.concurrency=2",
			"spring.jms.listener.maxConcurrency=10");
	JmsListenerContainerFactory<?> jmsListenerContainerFactory = this.context.getBean(
			"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
	assertEquals(DefaultJmsListenerContainerFactory.class,
			jmsListenerContainerFactory.getClass());
	DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
			.createListenerContainer(mock(JmsListenerEndpoint.class));
	assertEquals(false, listenerContainer.isAutoStartup());
	assertEquals(Session.CLIENT_ACKNOWLEDGE,
			listenerContainer.getSessionAcknowledgeMode());
	assertEquals(2, listenerContainer.getConcurrentConsumers());
	assertEquals(10, listenerContainer.getMaxConcurrentConsumers());
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Test
public void testDefaultContainerFactoryWithJtaTransactionManager() {
	this.context = createContext(TestConfiguration7.class,
			EnableJmsConfiguration.class);
	JmsListenerContainerFactory<?> jmsListenerContainerFactory = this.context.getBean(
			"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
	assertEquals(DefaultJmsListenerContainerFactory.class,
			jmsListenerContainerFactory.getClass());
	DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
			.createListenerContainer(mock(JmsListenerEndpoint.class));
	assertFalse("wrong session transacted flag with JTA transactions",
			listenerContainer.isSessionTransacted());
	assertSame(this.context.getBean(JtaTransactionManager.class),
			new DirectFieldAccessor(listenerContainer)
					.getPropertyValue("transactionManager"));
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> jmsListenerContainerFactory(ConnectionFactory connectionFactory) {
    DefaultJmsListenerContainerFactory factory =
            new DefaultJmsListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    factory.setConcurrency("2-16");
    return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> myFactory(ConnectionFactory connectionFactory,
                                                DefaultJmsListenerContainerFactoryConfigurer configurer) {
    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    configurer.configure(factory, connectionFactory);
    return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Override
public void registerListenerContainer(JmsListenerEndpoint endpoint,
    JmsListenerContainerFactory<?> factory, boolean startImmediately) {
  if (endpoint instanceof MethodJmsListenerEndpoint) {
    endpoint = replaceMethodJmsListenerEndpoint((MethodJmsListenerEndpoint) endpoint);
  }
  super.registerListenerContainer(endpoint, factory, startImmediately);
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> myFactory(ConnectionFactory connectionFactory,
    DefaultJmsListenerContainerFactoryConfigurer configurer) {
  DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
  // This provides all boot's default to this factory, including the message converter
  configurer.configure(factory, connectionFactory);
  // You could still override some of Boot's default if necessary.
  return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
JmsListenerContainerFactory<?> myJmsContainerFactory(ConnectionFactory connectionFactory){
	SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
	factory.setConnectionFactory(connectionFactory);
	factory.setPubSubDomain(true);
	return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
    DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
    bean.setPubSubDomain(true);
    bean.setConnectionFactory(activeMQConnectionFactory);
    return bean;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> asyncEngineFactory(ConnectionFactory connectionFactory,
                                                DefaultJmsListenerContainerFactoryConfigurer configurer) {
    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    // This provides all boot's default to this factory, including the message converter
    configurer.configure(factory, connectionFactory);
    // You could still override some of Boot's default if necessary.
    return factory;
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Override
public void registerListenerContainer(JmsListenerEndpoint endpoint, JmsListenerContainerFactory<?> factory) {
    JmsListenerEndpoint jmsListenerEndpoint = endpoint;
    if (endpoint instanceof MethodJmsListenerEndpoint) {
        MethodJmsListenerEndpointAdapter methodEndpoint = new MethodJmsListenerEndpointAdapter(
                (MethodJmsListenerEndpoint) endpoint, messageHandlerMethodFactory);
        methodEndpoint.setBeanFactory(beanFactory);
        jmsListenerEndpoint = methodEndpoint;
    }
    super.registerListenerContainer(jmsListenerEndpoint, factory);
}
 

import org.springframework.jms.config.JmsListenerContainerFactory; //导入依赖的package包/类
@Bean
public JmsListenerContainerFactory<?> myFactory(ConnectionFactory connectionFactory,
                                                DefaultJmsListenerContainerFactoryConfigurer configurer) {
	DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
	// This provides all boot's default to this factory, including the message converter
	configurer.configure(factory, connectionFactory);
	// You could still override some of Boot's default if necessary.
	return factory;
}