Spring boot RocketMQ消费者等待结果回调

我正在使用RocketMQ，希望从队列中获取每个新请求的消息

@Service
public class GetMessageFromQueue extends BaseObject {
@Resource
private RocketMQTemplate rocketMQTemplate;

@Value("${demo.rocketmq.topic}")
private String springTopic;

private String ms;

public void getMessage(InternalRequest internalRequest) throws MyExeption {
    logger.info("sending message='{}'", inputData.getData());

    CountDownLatch loginLatch = new CountDownLatch (1);
    DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(inputData.getCorrID());
    consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
    try {
        //get message by TAG to filter only messsage I want
        consumer.subscribe(springTopic, inputData.getCorrID());
        consumer.registerMessageListener(new MessageListenerConcurrently() {
            @Override
            public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                logger.info("consumeMessage " + msgs.size());
                for (MessageExt messageExt : msgs) {
                    logger.info("consumeMessage " + new String(messageExt.getBody()));
                    ms = new String(messageExt.getBody());
                }
                loginLatch.countDown ();
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
        });
        consumer.start();
    } catch (MQClientException e) {
        e.printStackTrace();
        logger.error("e " + e);
    }

    try {
        loginLatch.await ();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    consumer.shutdown();

    logger.info("ms " + ms);
    if(!inputData.getCorrID().equals(ms)) {
        throw new MyExeption ("500",ms,ms);
    }
    logger.info("get done " + ms);
}
}

@服务
公共类GetMessageFromQueue扩展了BaseObject{
@资源
私人火箭发射台火箭发射台；
@值（${demo.rocketmq.topic}”）
私人话题；
私有字符串ms；
public void getMessage（InternalRequest InternalRequest）抛出MyExeption{
info（“发送消息='{}'，inputData.getData（））；
CountDownLatch loginLatch=新的CountDownLatch（1）；
DefaultMQPushConsumer=新的DefaultMQPushConsumer（inputData.getCorrID（））；
consumer.setconsumerfromwhere（consumerfromwhere.consumer\u FROM\u FIRST\u OFFSET）；
试一试{
//按标记获取消息以仅筛选我想要的消息
subscribe（springTopic，inputData.getCorrID（））；
consumer.registerMessageListener（新MessageListener）（）{
@凌驾
公共ConsumerConcurrentLyStatus ConsumerMessage（列出MSG、ConsumerConcurrentLyContext上下文）{
logger.info（“consumeMessage”+msgs.size（））；
for（MessageExt:msgs）{
info（“consumeMessage”+新字符串（messageExt.getBody（））；
ms=新字符串（messageExt.getBody（））；
}
loginLatch.countDown（）；
返回consumerconcurrentystatus.consumer\u SUCCESS；
}
});
consumer.start（）；
}捕获（MQClientException e）{
e、 printStackTrace（）；
记录器错误（“e”+e）；
}
试一试{
loginLatch.await（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
consumer.shutdown（）；
记录器信息（“毫秒”+毫秒）；
如果（！inputData.getCorrID（）.equals（ms））{
抛出新的MyExeption（“500”，毫秒，毫秒）；
}
logger.info（“完成”+ms）；
}
}

此代码在正常情况下工作正常。 但是，如果我运行多个并发线程，ms varrable有时无法从MessageListenerConcurrent回调中获得确切的值

我哪里错了？

---

我怎么能在这里等待消费者的结果呢？

我认为这个计划其实很奇怪。让我指出一些错误的东西，这样你就可以找出你的实际问题

您有一个初始值为1的闩锁。消费者被消费线程池中的消息所消费，消息可能很多，这意味着消费者可以并行消费两条消息，比如msg1和msg2，变量的值可以被假定为msg1或msg2，这是未经验证的

每次调用方法时，都会创建使用者并关闭它。因此，消费者补偿可能不会及时更新到代理，消费者将关闭，这意味着下次使用相同的消费者组启动消费者时，相同的消息将再次被消费

消费者被设置为从第一个偏移量消费，这真的是你想要的吗？这意味着，如果有10条消息已发送到主题，则在新消费者（具有新消费者组）启动时，您可能会始终使用第一条消息