How to use org.springframework.amqp.rabbit.listener

@Bean
SimpleMessageListenerContainer container(ConnectionFactory connectionFactory,
                     MessageListenerAdapter listenerAdapter) {
  SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
  container.setConnectionFactory(connectionFactory);
  container.setQueueNames(queueName);
  container.setMessageListener(listenerAdapter);
  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) {
      channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
  });
  return container;
}

@Override
public void stop() {
  if (this.container != null) {
    this.container.stop();
    this.declared = false;
  }
}

/**
 * @param concurrentConsumers the concurrentConsumers
 * @return the spec.
 * @see SimpleMessageListenerContainer#setConcurrentConsumers(int)
 */
public SimpleMessageListenerContainerSpec concurrentConsumers(int concurrentConsumers) {
  this.listenerContainer.setConcurrentConsumers(concurrentConsumers);
  return this;
}

@Override
public void resume() {
  if (!container.isRunning()) {
    container.start();
  }
}

/**
 * @param maxConcurrentConsumers the maxConcurrentConsumers.
 * @return the spec.
 * @see SimpleMessageListenerContainer#setMaxConcurrentConsumers(int)
 */
public SimpleMessageListenerContainerSpec maxConcurrentConsumers(int maxConcurrentConsumers) {
  this.listenerContainer.setMaxConcurrentConsumers(maxConcurrentConsumers);
  return this;
}

@Override
public void pause() {
  if (container.isRunning()) {
    container.stop();
  }
}

/**
 * @param txSize the txSize.
 * @return the spec.
 * @see SimpleMessageListenerContainer#setTxSize(int)
 */
public SimpleMessageListenerContainerSpec txSize(int txSize) {
  this.listenerContainer.setTxSize(txSize);
  return this;
}

/**
 * @param receiveTimeout the receiveTimeout
 * @return the spec.
 * @see SimpleMessageListenerContainer#setReceiveTimeout(long)
 */
public SimpleMessageListenerContainerSpec receiveTimeout(long receiveTimeout) {
  this.listenerContainer.setReceiveTimeout(receiveTimeout);
  return this;
}

/**
 * @param startConsumerMinInterval the startConsumerMinInterval
 * @return the spec.
 * @see SimpleMessageListenerContainer#setStartConsumerMinInterval(long)
 */
public SimpleMessageListenerContainerSpec startConsumerMinInterval(long startConsumerMinInterval) {
  this.listenerContainer.setStartConsumerMinInterval(startConsumerMinInterval);
  return this;
}

/**
 * @param consecutiveActiveTrigger the consecutiveActiveTrigger.
 * @return the spec.
 * @see SimpleMessageListenerContainer#setConsecutiveActiveTrigger(int)
 */
public SimpleMessageListenerContainerSpec consecutiveActiveTrigger(int consecutiveActiveTrigger) {
  this.listenerContainer.setConsecutiveActiveTrigger(consecutiveActiveTrigger);
  return this;
}

/**
 * @param consecutiveIdleTrigger the consecutiveIdleTrigger.
 * @return the spec.
 * @see SimpleMessageListenerContainer#setConsecutiveIdleTrigger(int)
 */
public SimpleMessageListenerContainerSpec consecutiveIdleTrigger(int consecutiveIdleTrigger) {
  this.listenerContainer.setConsecutiveIdleTrigger(consecutiveIdleTrigger);
  return this;
}

/**
 * @param stopConsumerMinInterval the stopConsumerMinInterval.
 * @return the spec.
 * @see SimpleMessageListenerContainer#setStopConsumerMinInterval(long)
 */
public SimpleMessageListenerContainerSpec stopConsumerMinInterval(long stopConsumerMinInterval) {
  this.listenerContainer.setStopConsumerMinInterval(stopConsumerMinInterval);
  return this;
}

/**
 * @param consumersPerQueue the consumersPerQueue.
 * @return the spec.
 * @see DirectMessageListenerContainer#setConsumersPerQueue(int)
 */
public DirectMessageListenerContainerSpec consumersPerQueue(int consumersPerQueue) {
  this.listenerContainer.setConsumersPerQueue(consumersPerQueue);
  return this;
}

@Override
protected void doStart() {
  this.messageListenerContainer.start();
}

/**
 * @param ackTimeout the ack timeout.
 * @return the spec.
 * @see DirectMessageListenerContainer#setAckTimeout(long)
 */
public DirectMessageListenerContainerSpec ackTimeout(long ackTimeout) {
  this.listenerContainer.setAckTimeout(ackTimeout);
  return this;
}

/**
 * @param messagesPerAck the messages per ack.
 * @return the spec.
 * @see DirectMessageListenerContainer#setMessagesPerAck(int)
 */
public DirectMessageListenerContainerSpec messagesPerAck(int messagesPerAck) {
  this.listenerContainer.setMessagesPerAck(messagesPerAck);
  return this;
}

@Override
public boolean isRunning() {
  return (this.container != null) && this.container.isRunning();
}

/**
 * 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;
}

/**
 * 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;
}