org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer Java Examples

@Override
public void send(Message message, String destination) {
	final String routingKey = message.getMessageProperties().getReceivedRoutingKey();
	List<SimpleMessageListenerContainer> listenerContainers = this.messageListenerAccessor
			.getListenerContainersForDestination(destination, routingKey);
	if (listenerContainers.isEmpty()) {
		throw new IllegalStateException(
				"no listeners found for destination " + destination);
	}
	for (SimpleMessageListenerContainer listenerContainer : listenerContainers) {
		Object messageListener = listenerContainer.getMessageListener();
		if (isChannelAwareListener(listenerContainer, messageListener)) {
			try {
				((ChannelAwareMessageListener) messageListener).onMessage(message,
						createChannel(listenerContainer, transactionalChannel()));
			}
			catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		else {
			((MessageListener) messageListener).onMessage(message);
		}
	}
}
 

@Bean
@ConditionalOnProperty(value = EventbusConstant.Rabbit.LISTENER_PACKAGES)
public SimpleMessageListenerContainer messageContainer(Queue queue, EventDispatcher eventDispatcher) {
    for (String topic : eventDispatcher.getAllTopics()) {
        this.initExchange(topic,queue);
    }

    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
    container.setQueues(queue);
    container.setMessageConverter(messageConverter());
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(1);
    container.setConcurrentConsumers(1);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认

    RabbitEventArgListener listener = new RabbitEventArgListener(eventDispatcher);
    container.setMessageListener(listener);
    return container;
}
 

@Bean
public SimpleMessageListenerContainer messageContainer() {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
    container.setQueues(queue());
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(1);
    container.setConcurrentConsumers(1);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    container.setMessageListener(new ChannelAwareMessageListener() {

        public void onMessage(Message message, com.rabbitmq.client.Channel channel) throws Exception {
            byte[] body = message.getBody();
            logger.info("消费端接收到消息 : " + new String(body));
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    });
    return container;
}
 

/**
 * Message container simple message listener container.
 *
 * @return the simple message listener container
 */
@Bean
@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "host")
public SimpleMessageListenerContainer messageContainer() {
    SimpleMessageListenerContainer container =
            new SimpleMessageListenerContainer(connectionFactory);
    container.setQueues(queue());
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(3);
    container.setConcurrentConsumers(1);
    //设置确认模式手工确认
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    container.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
        byte[] messageBody = message.getBody();
        LogUtil.debug(LOGGER, () -> "springcloud  account服务  amqp接收消息");
        //确认消息成功消费
        final Boolean success = mythMqReceiveService.processMessage(messageBody);
        if (success) {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    });
    return container;
}
 

@Bean
@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "host")
public SimpleMessageListenerContainer messageContainer() {
    SimpleMessageListenerContainer container =
            new SimpleMessageListenerContainer(connectionFactory);
    container.setQueues(queue());
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(1);
    container.setConcurrentConsumers(1);
    //设置确认模式手工确认
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    container.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
        byte[] messageBody = message.getBody();
        //确认消息成功消费
        final Boolean success = mythMqReceiveService.processMessage(messageBody);
        if (success) {
            try {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });
    return container;
}
 

/**
 * Message container simple message listener container.
 *
 * @return the simple message listener container
 */
@Bean
@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "host")
public SimpleMessageListenerContainer messageContainer() {
    SimpleMessageListenerContainer container =
            new SimpleMessageListenerContainer(connectionFactory);
    container.setQueues(queue());
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(2);
    container.setConcurrentConsumers(1);
    //设置确认模式手工确认
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    container.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
        byte[] messageBody = message.getBody();
        LOGGER.debug("motan 框架接收到的消息");
        //确认消息成功消费
        final Boolean success = mythMqReceiveService.processMessage(messageBody);
        if (success) {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
    });
    return container;
}
 

@Test
public void testAnonWithBuiltInExchangeCustomPrefix() throws Exception {
	RabbitTestBinder binder = getBinder();
	ExtendedConsumerProperties<RabbitConsumerProperties> properties = createConsumerProperties();
	properties.getExtension().setDeclareExchange(false);
	properties.getExtension().setQueueNameGroupOnly(true);
	properties.getExtension().setAnonymousGroupPrefix("customPrefix.");

	Binding<MessageChannel> consumerBinding = binder.bindConsumer("amq.topic", null,
			createBindableChannel("input", new BindingProperties()), properties);
	Lifecycle endpoint = extractEndpoint(consumerBinding);
	SimpleMessageListenerContainer container = TestUtils.getPropertyValue(endpoint,
			"messageListenerContainer", SimpleMessageListenerContainer.class);
	String queueName = container.getQueueNames()[0];
	assertThat(queueName).startsWith("customPrefix.");
	assertThat(container.isRunning()).isTrue();
	consumerBinding.unbind();
	assertThat(container.isRunning()).isFalse();
}
 

@Test
public void testAnonWithBuiltInExchange() throws Exception {
	RabbitTestBinder binder = getBinder();
	ExtendedConsumerProperties<RabbitConsumerProperties> properties = createConsumerProperties();
	properties.getExtension().setDeclareExchange(false);
	properties.getExtension().setQueueNameGroupOnly(true);

	Binding<MessageChannel> consumerBinding = binder.bindConsumer("amq.topic", null,
			createBindableChannel("input", new BindingProperties()), properties);
	Lifecycle endpoint = extractEndpoint(consumerBinding);
	SimpleMessageListenerContainer container = TestUtils.getPropertyValue(endpoint,
			"messageListenerContainer", SimpleMessageListenerContainer.class);
	String queueName = container.getQueueNames()[0];
	assertThat(queueName).startsWith("anonymous.");
	assertThat(container.isRunning()).isTrue();
	consumerBinding.unbind();
	assertThat(container.isRunning()).isFalse();
}
 

private List<SimpleMessageListenerContainer> getListenersByBoundQueues(
		List<SimpleMessageListenerContainer> listenerContainers,
		Set<String> queueNames) {
	List<SimpleMessageListenerContainer> matchingContainers = new ArrayList<>();
	for (SimpleMessageListenerContainer listenerContainer : listenerContainers) {
		if (listenerContainer.getQueueNames() != null) {
			for (String queueName : listenerContainer.getQueueNames()) {
				if (queueNames.contains(queueName)) {
					matchingContainers.add(listenerContainer);
					break;
				}
			}
		}
	}
	return matchingContainers;
}
 

private void setSMLCProperties(
		ExtendedConsumerProperties<RabbitConsumerProperties> properties,
		SimpleMessageListenerContainer listenerContainer, int concurrency) {

	listenerContainer.setConcurrentConsumers(concurrency);
	int maxConcurrency = properties.getExtension().getMaxConcurrency();
	if (maxConcurrency > concurrency) {
		listenerContainer.setMaxConcurrentConsumers(maxConcurrency);
	}
	listenerContainer.setDeBatchingEnabled(!properties.isBatchMode());
	listenerContainer.setBatchSize(properties.getExtension().getBatchSize());
	if (properties.getExtension().getQueueDeclarationRetries() != null) {
		listenerContainer.setDeclarationRetries(
				properties.getExtension().getQueueDeclarationRetries());
	}
}
 

private List<SimpleMessageListenerContainer> collectListenerContainers() {
	List<SimpleMessageListenerContainer> listenerContainers = new ArrayList<>();
	if (this.simpleMessageListenerContainers != null) {
		listenerContainers.addAll(this.simpleMessageListenerContainers);
	}
	if (this.rabbitListenerEndpointRegistry != null) {
		for (MessageListenerContainer listenerContainer : this.rabbitListenerEndpointRegistry
				.getListenerContainers()) {
			if (listenerContainer instanceof SimpleMessageListenerContainer) {
				listenerContainers
						.add((SimpleMessageListenerContainer) listenerContainer);
			}
		}
	}
	return listenerContainers;
}
 

@Test
public void testConsumerPropertiesWithUserInfrastructureNoBind() throws Exception {
	RabbitAdmin admin = new RabbitAdmin(this.rabbitAvailableRule.getResource());
	Queue queue = new Queue("propsUser1.infra");
	admin.declareQueue(queue);
	DirectExchange exchange = new DirectExchange("propsUser1");
	admin.declareExchange(exchange);
	admin.declareBinding(BindingBuilder.bind(queue).to(exchange).with("foo"));

	RabbitTestBinder binder = getBinder();
	ExtendedConsumerProperties<RabbitConsumerProperties> properties = createConsumerProperties();
	properties.getExtension().setDeclareExchange(false);
	properties.getExtension().setBindQueue(false);

	Binding<MessageChannel> consumerBinding = binder.bindConsumer("propsUser1",
			"infra", createBindableChannel("input", new BindingProperties()),
			properties);
	Lifecycle endpoint = extractEndpoint(consumerBinding);
	SimpleMessageListenerContainer container = TestUtils.getPropertyValue(endpoint,
			"messageListenerContainer", SimpleMessageListenerContainer.class);
	assertThat(TestUtils.getPropertyValue(container, "missingQueuesFatal",
			Boolean.class)).isFalse();
	assertThat(container.isRunning()).isTrue();
	consumerBinding.unbind();
	assertThat(container.isRunning()).isFalse();
	Client client = new Client("http://guest:guest@localhost:15672/api/");
	List<?> bindings = client.getBindingsBySource("/", exchange.getName());
	assertThat(bindings.size()).isEqualTo(1);
}
 

@Bean
SimpleMessageListenerContainer messageListenerContainer(
		ConnectionFactory connectionFactory, RabbitTemplate rabbitTemplate) {
	SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
	container.setConnectionFactory(connectionFactory);
	container.addQueueNames("rated-item-service.rated-item-event.exchange");
	container.setMessageListener(exampleListener(rabbitTemplate));
	return container;
}
 

@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(
		ConnectionFactory connectionFactory,
		MessageListenerAdapter listenerAdapter) {
	SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
	container.setConnectionFactory(connectionFactory);
	container.setQueueNames("test.queue");
	container.setMessageListener(listenerAdapter);

	return container;
}
 

MessageListenerAccessor(RabbitListenerEndpointRegistry rabbitListenerEndpointRegistry,
		List<SimpleMessageListenerContainer> simpleMessageListenerContainers,
		List<Binding> bindings) {
	this.rabbitListenerEndpointRegistry = rabbitListenerEndpointRegistry;
	this.simpleMessageListenerContainers = simpleMessageListenerContainers;
	this.bindings = bindings;
}
 

List<SimpleMessageListenerContainer> getListenerContainersForDestination(
		String destination, String routingKey) {
	List<SimpleMessageListenerContainer> listenerContainers = collectListenerContainers();
	// we interpret the destination as exchange name and collect all the queues bound
	// to this exchange
	Set<String> queueNames = collectQueuesBoundToDestination(destination, routingKey);
	return getListenersByBoundQueues(listenerContainers, queueNames);
}
 

@Bean
SimpleMessageListenerContainer containerAnaylsis(ConnectionFactory connectionFactory) {
	SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
	container.setConnectionFactory(connectionFactory());
	container.setQueueNames(queueNameSzz);
	container.setMessageListener(new MessageReceivedComponent(rabbitTemplate(connectionFactory()), dbEntryDao));
	return container;
}
 

private SimpleMessageListenerContainer verifyContainer(Lifecycle endpoint) {
	SimpleMessageListenerContainer container;
	RetryTemplate retry;
	container = TestUtils.getPropertyValue(endpoint, "messageListenerContainer",
			SimpleMessageListenerContainer.class);
	assertThat(container.getAcknowledgeMode()).isEqualTo(AcknowledgeMode.NONE);
	assertThat(container.getQueueNames()[0]).startsWith("foo.props.0");
	assertThat(TestUtils.getPropertyValue(container, "transactional", Boolean.class))
			.isFalse();
	assertThat(TestUtils.getPropertyValue(container, "concurrentConsumers"))
			.isEqualTo(2);
	assertThat(TestUtils.getPropertyValue(container, "maxConcurrentConsumers"))
			.isEqualTo(3);
	assertThat(TestUtils.getPropertyValue(container, "defaultRequeueRejected",
			Boolean.class)).isFalse();
	assertThat(TestUtils.getPropertyValue(container, "prefetchCount")).isEqualTo(20);
	assertThat(TestUtils.getPropertyValue(container, "batchSize")).isEqualTo(10);
	retry = TestUtils.getPropertyValue(endpoint, "retryTemplate",
			RetryTemplate.class);
	assertThat(TestUtils.getPropertyValue(retry, "retryPolicy.maxAttempts"))
			.isEqualTo(23);
	assertThat(TestUtils.getPropertyValue(retry, "backOffPolicy.initialInterval"))
			.isEqualTo(2000L);
	assertThat(TestUtils.getPropertyValue(retry, "backOffPolicy.maxInterval"))
			.isEqualTo(20000L);
	assertThat(TestUtils.getPropertyValue(retry, "backOffPolicy.multiplier"))
			.isEqualTo(5.0);

	List<?> requestMatchers = TestUtils.getPropertyValue(endpoint,
			"headerMapper.requestHeaderMatcher.matchers", List.class);
	assertThat(requestMatchers).hasSize(1);
	assertThat(TestUtils.getPropertyValue(requestMatchers.get(0), "pattern"))
			.isEqualTo("foo");

	return container;
}
 

@Bean
public SimpleMessageListenerContainer messageListenerContainer(MessageListenerAdapter listenerAdapter) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(connectionFactory());
    container.setQueueNames(AmqpConfig.QUEUE_NAME);
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(1);
    container.setConcurrentConsumers(1);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
    container.setMessageListener(listenerAdapter);
    return container;
}
 

@Bean
SimpleMessageListenerContainer container_emsRegistrator() {
  if (listenerAdapter_emsRegistrator != null) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(emsConnectionFactory);
    container.setQueueNames(queueName_emsRegistrator);
    container.setMessageListener(listenerAdapter_emsRegistrator);
    return container;
  } else return null;
}
 

@Override
// Exception squid:UnusedProtectedMethod - called by
// AbstractRabbitListenerContainerFactory
@SuppressWarnings("squid:UnusedProtectedMethod")
protected void initializeContainer(final SimpleMessageListenerContainer instance,
        final RabbitListenerEndpoint endpoint) {
    super.initializeContainer(instance, endpoint);
    instance.setDeclarationRetries(declarationRetries);
}
 

/**
 * Create RabbitListenerContainerFactory bean if no listenerContainerFactory
 * bean found
 *
 * @return RabbitListenerContainerFactory bean
 */
@Bean
@ConditionalOnMissingBean(name = "listenerContainerFactory")
public RabbitListenerContainerFactory<SimpleMessageListenerContainer> listenerContainerFactory(
        final SimpleRabbitListenerContainerFactoryConfigurer configurer, final ErrorHandler errorHandler) {
    final ConfigurableRabbitListenerContainerFactory factory = new ConfigurableRabbitListenerContainerFactory(
            amqpProperties.isMissingQueuesFatal(), amqpProperties.getDeclarationRetries(), errorHandler);
    configurer.configure(factory, rabbitConnectionFactory);
    return factory;
}
 

@Bean
public SimpleMessageListenerContainer listenerContainer() {
	SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
	container.setConnectionFactory(connectionFactory());
	container.setQueueNames(this.scrapingResultQueue);
	container.setMessageListener(messageListenerAdapter());

	return container;
}
 

/**
 * {@link SimpleMessageListenerContainer}のインスタンスを生成します。
 * このインスタンスを生成後にRabbitMQへのコネクション{@link #factory()}の設定や
 * メッセージ受信側での例外ハンドラ{@link #errorHandler()}の設定、
 * リトライ処理{@link #advice()}の設定を行います。
 * @return {@link SimpleMessageListenerContainer}のインスタンス
 */
protected SimpleMessageListenerContainer messageListenerContainer() {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(factory());
    container.setErrorHandler(errorHandler());
    container.setAdviceChain(advice());
    return container;
}
 

private SimpleMessageListenerContainer container() {
    SimpleMessageListenerContainer c = new SimpleMessageListenerContainer(ctx.getBean(ConnectionFactory.class));
    c.setConnectionFactory(ctx.getBean(ConnectionFactory.class));
    c.setErrorHandler(ctx.getBean(ErrorHandler.class));
    c.setAdviceChain(ctx.getBean(Advice[].class));
    return c;
}
 

@Bean
public SimpleMessageListenerContainer listenerContainer(ConnectionFactory connectionFactory, TestMessageHandler testMessageHandler) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    container.setQueueNames(RabbitMQTestConstants.QUEUE_PUSH);
    container.setMessageListener(new MessageListenerAdapter(testMessageHandler));
    return container;
}
 

@Bean(destroyMethod = "destroy")
public SimpleMessageListenerContainer simpleMessageListenerContainer() {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
    container.setQueues(queue());
    container.setMessageListener(loggingMessageListenerAdapter());
    container.setAcknowledgeMode(AcknowledgeMode.AUTO);

    return container;
}
 

@Bean
public SimpleMessageListenerContainer messageContainer(ConnectionFactory connectionFactory, MessageListenerAdapter messageListenerAdapter) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
    container.setQueues(this.queue);
    container.setExposeListenerChannel(true);
    container.setMaxConcurrentConsumers(this.maxConcurrentConsumers);
    container.setConcurrentConsumers(this.concurrentConsumers);
    container.setAcknowledgeMode(AcknowledgeMode.AUTO);
    container.setMessageListener(messageListenerAdapter);
    return container;
}
 

@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer(MessageConverter converter,
    ConnectionFactory connectionFactory, @Autowired(required = false) List<Consumer<?>> list) {
  SimpleMessageListenerContainer container =
      new SimpleMessageListenerContainer(connectionFactory);
  init(list);
  Receiver receiver = new Receiver(converter);
  container.setMessageListener(new MessageListenerAdapter(receiver, converter));
  container.setQueueNames(queueNames.toArray(new String[0]));
  container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
  container.setPrefetchCount(prefetchCount);
  container.setTxSize(txSize);
  return container;
}
 

@Bean
SimpleMessageListenerContainer containerAnaylsis(ConnectionFactory connectionFactory) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(connectionFactory());
    container.setQueueNames(queueNameSzz);
    container.setMessageListener(new MessageReceivedComponent(rabbitTemplate(connectionFactory())));
    return container;
}