Java SimpleRabbitListenerContainerFactory类代码示例

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "rabbitListenerContainerFactory")
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
		ConnectionFactory connectionFactory, RabbitProperties config) {
	SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
	factory.setConnectionFactory(connectionFactory);
	Listener listenerConfig = config.getListener();
	factory.setAutoStartup(listenerConfig.isAutoStartup());
	if (listenerConfig.getAcknowledgeMode() != null) {
		factory.setAcknowledgeMode(listenerConfig.getAcknowledgeMode());
	}
	if (listenerConfig.getConcurrency() != null) {
		factory.setConcurrentConsumers(listenerConfig.getConcurrency());
	}
	if (listenerConfig.getMaxConcurrency() != null) {
		factory.setMaxConcurrentConsumers(listenerConfig.getMaxConcurrency());
	}
	if (listenerConfig.getPrefetch() != null) {
		factory.setPrefetchCount(listenerConfig.getPrefetch());
	}
	if (listenerConfig.getTransactionSize() != null) {
		factory.setTxSize(listenerConfig.getTransactionSize());
	}
	return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "rabbitListenerContainerFactory")
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory() {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    factory.setMessageConverter(messageConverter);
    factory.setDefaultRequeueRejected(rabbitProperties.getDefaultRequeueRejected());
    factory.setErrorHandler(new DefaultErrorHandler());

    return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
private SimpleRabbitListenerContainerFactory createContainerFactory (int aConcurrency) {
  SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
  factory.setConcurrentConsumers(aConcurrency);
  factory.setConnectionFactory(connectionFactory);
  factory.setDefaultRequeueRejected(false);
  factory.setMessageConverter(jacksonAmqpMessageConverter(objectMapper));
  return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "rabbitListenerContainerFactory")
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(
		SimpleRabbitListenerContainerFactoryConfigurer configurer,
		ConnectionFactory connectionFactory) {
	SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
	configurer.configure(factory, connectionFactory);
	return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Test
public void testEnableRabbitCreateDefaultContainerFactory() {
	load(EnableRabbitConfiguration.class);
	RabbitListenerContainerFactory<?> rabbitListenerContainerFactory = this.context
			.getBean("rabbitListenerContainerFactory",
					RabbitListenerContainerFactory.class);
	assertThat(rabbitListenerContainerFactory.getClass())
			.isEqualTo(SimpleRabbitListenerContainerFactory.class);
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Test
public void testRabbitListenerContainerFactoryBackOff() {
	load(TestConfiguration5.class);
	SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = this.context
			.getBean("rabbitListenerContainerFactory",
					SimpleRabbitListenerContainerFactory.class);
	rabbitListenerContainerFactory.setTxSize(10);
	verify(rabbitListenerContainerFactory).setTxSize(10);
	DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitListenerContainerFactory);
	Advice[] adviceChain = (Advice[]) dfa.getPropertyValue("adviceChain");
	assertThat(adviceChain).isNull();
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    factory.setConcurrentConsumers(3);
    factory.setMaxConcurrentConsumers(10);
    return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Test
public void testEnableRabbitCreateDefaultContainerFactory() {
	load(EnableRabbitConfiguration.class);
	RabbitListenerContainerFactory<?> rabbitListenerContainerFactory = this.context
			.getBean("rabbitListenerContainerFactory",
					RabbitListenerContainerFactory.class);
	assertEquals(SimpleRabbitListenerContainerFactory.class,
			rabbitListenerContainerFactory.getClass());
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Test
public void testRabbitListenerContainerFactoryBackOff() {
	load(TestConfiguration5.class);
	SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = this.context
			.getBean("rabbitListenerContainerFactory",
					SimpleRabbitListenerContainerFactory.class);
	rabbitListenerContainerFactory.setTxSize(10);
	verify(rabbitListenerContainerFactory).setTxSize(10);
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Test
public void testRabbitListenerContainerFactoryWithCustomSettings() {
	load(TestConfiguration.class, "spring.rabbitmq.listener.autoStartup:false",
			"spring.rabbitmq.listener.acknowledgeMode:manual",
			"spring.rabbitmq.listener.concurrency:5",
			"spring.rabbitmq.listener.maxConcurrency:10",
			"spring.rabbitmq.listener.prefetch=40",
			"spring.rabbitmq.listener.transactionSize:20");
	SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = this.context
			.getBean("rabbitListenerContainerFactory",
					SimpleRabbitListenerContainerFactory.class);
	DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitListenerContainerFactory);
	assertEquals(false, dfa.getPropertyValue("autoStartup"));
	assertEquals(AcknowledgeMode.MANUAL, dfa.getPropertyValue("acknowledgeMode"));
	assertEquals(5, dfa.getPropertyValue("concurrentConsumers"));
	assertEquals(10, dfa.getPropertyValue("maxConcurrentConsumers"));
	assertEquals(40, dfa.getPropertyValue("prefetchCount"));
	assertEquals(20, dfa.getPropertyValue("txSize"));
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
/**
 * enables support for @RabbitListener
 * @param configurer
 * @return
 */
@Bean
public SimpleRabbitListenerContainerFactory myFactory(
    SimpleRabbitListenerContainerFactoryConfigurer configurer) {
  SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
  configurer.configure(factory, connectionFactory);
  // factory.setMessageConverter(myMessageConverter());
  return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(org.springframework.amqp.rabbit.connection.ConnectionFactory  cf,
                                                                    ObjectMapper mapper) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(cf);
    factory.setMessageConverter(new Jackson2JsonMessageConverter(mapper));
    return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    // factory.setPrefetchCount(5);

    factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
    return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
@Bean
@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "host")
public SimpleRabbitListenerContainerFactory myContainerFactory(
        SimpleRabbitListenerContainerFactoryConfigurer configurer,
        ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setPrefetchCount(100);
    configurer.configure(factory, connectionFactory);
    return factory;
}
 

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory; //导入依赖的package包/类
private void initRabbitMQ() throws URISyntaxException {
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory(new URI(host));

    Map<String, Object> cmdQueueArgs = new HashMap<>();
    cmdQueueArgs.put("x-max-length", maxSize);
    cmdQueueArgs.put("x-max-priority", maxPriority);
    Queue cmdQueue = new Queue(name, true, false, false, cmdQueueArgs);

    RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
    rabbitAdmin.declareQueue(cmdQueue);

    // setup listener container factory
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    factory.setConnectionFactory(connectionFactory);
    factory.setConcurrentConsumers(DEFAULT_CONCURRENCY);
    factory.setMaxConcurrentConsumers(DEFAULT_CONCURRENCY);
    factory.setTaskExecutor(executor);
    factory.setAutoStartup(false);

    // setup rabbit template
    template = new RabbitTemplate(connectionFactory);
    template.setQueue(name);

    // setup container
    SimpleRabbitListenerEndpoint simpleEndpoint = new SimpleRabbitListenerEndpoint();
    simpleEndpoint.setMessageListener(new RabbitMessageListener());

    container = factory.createListenerContainer(simpleEndpoint);
    container.setQueueNames(name);
    LOGGER.trace("RabbitMQ initialized on '%s' with queue name '%s'", host, name);
}