RabbitMQ Consumer只使用发送的部分消息

Question

我正在向RabbitMQ发送少量消息，但使用者仅消耗其中的两个。 在下面找到我的生产者和消费者的代码：

@Component
public class Producer implements CommandLineRunner {

private final RabbitTemplate rabbitTemplate;
private final Consumer receiver;
private final ConfigurableApplicationContext context;

public Producer(Consumer receiver, RabbitTemplate rabbitTemplate,
        ConfigurableApplicationContext context) {
    this.receiver = receiver;
    this.rabbitTemplate = rabbitTemplate;
    this.context = context;
}

private List<Message> extractphoneNumberNumbers(String path){
    List<Message> messages = new ArrayList();
    try{
        BufferedReader fileReader = new BufferedReader(
                  new InputStreamReader(new ClassPathResource(path).getInputStream()));
        JsonReader reader = new JsonReader(fileReader);
        Gson gson = new GsonBuilder().create();
        messages = new Gson().fromJson(reader, new TypeToken<List<Message>>() {}.getType());
    }catch(Exception e){
        System.out.println(e.getMessage());
    }
    return messages;
}

public void run(String... args) throws Exception {
    List<Message> messagesToPublish = extractphoneNumberNumbers("phoneNumbers");
    AtomicInteger messageId = new AtomicInteger();
    for(Message message : messagesToPublish){
        System.out.println("Sent " + message.toString());
        rabbitTemplate.convertAndSend(App.queueName, new Message(messageId.incrementAndGet(), message.getPhoneNumber()));
    }
    receiver.getLatch().await(10000, TimeUnit.MILLISECONDS);

    context.close();
}

}


@Component
public class Consumer {
private CountDownLatch latch = new CountDownLatch(1);
private HashMap<String, Integer> phoneCountryCode = new HashMap<String, Integer>();
private int i = 0;

public void receiveJsonMessages(Message message){
    System.out.println("Received " + message.toString());
    phoneCountryCode.put(message.getCountryCode(), phoneCountryCode.getOrDefault(message.getCountryCode(), 0) + 1);

    for(Map.Entry<String, Integer> entry : phoneCountryCode.entrySet()){
        System.out.println(entry.getKey() + " " + entry.getValue());
    }

    latch.countDown();
}

public CountDownLatch getLatch() {
    return latch;
}
}

---

Received 5 - +40722579707 - RO
Sent 0 - +447984627687 - GB
RO 1
Received 6 - +40722579717 - RO
Sent 0 - +447984627657 - GB
RO 2
Sent 0 - +447984627667 - GB
Sent 0 - +447984627677 - GB
Sent 0 - +40722579707 - RO
Sent 0 - +40722579717 - RO
Sent 0 - +40722579727 - RO

目标是按国家/地区对电话号码进行分组和计数。 我现在只是在玩RabbitMQ，没有经验，所以现在分组很愚蠢。

但问题是，为什么只收到两条消息，而不是7条？

编辑：我相信是由于这样的事实，即一旦工人（生产者）完成，豆子就会停止运转。 消费者完成后，如何配置它使其停止？

@SpringBootApplication
public class App {
final static String queueName = "rtap-queue";

@Bean
Queue queue() {
    return new Queue(queueName, false);
}

@Bean
TopicExchange exchange() {
    return new TopicExchange("rtap-exchange");
}

@Bean
Binding binding(Queue queue, TopicExchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with(queueName);
}

@Bean
SimpleMessageListenerContainer container(ConnectionFactory connectionFactory,
        MessageListenerAdapter listenerAdapter) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    container.setQueueNames(queueName);
    container.setMessageListener(listenerAdapter);
    container.setConcurrentConsumers(10);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    return container;
}

@Bean
MessageListenerAdapter listenerAdapter(Consumer receiver) {
    return new MessageListenerAdapter(receiver, "receiveJsonMessages");
}

public static void main(String[] args) throws InterruptedException {
    SpringApplication.run(App.class, args);
}
}

Answer 1

在此处关注示例， 网址为https://www.rabbitmq.com/tutorials/tutorial-one-spring-amqp.html 。 重要的是

@RabbitHandler
public void receive(String in) {
    System.out.println(" [x] Received '" + in + "'");
}

该方法在后台循环运行，并在有消息时使用它们。 如果您确实想关闭上述上下文，则需要知道将要使用的消息数，并使用预期的消息数配置CountDownLatch。 收到消息后，您可以倒计时并等待主线程中的闩锁。 但是，这并不保证您会收到所有消息，也不保证会发生任何故障，例如网络故障。 然后，您可以在闩锁等待上配置超时。