服务启动监听rocketMq消息

使用SmartLifecycle接口实现监听rocketMq消息

消费者基类，使用 SmartLifecycle 管理生命周期

/**
 * @Author 
 * @Date 2023/8/114:04
 * @CLassName AbstractMiddleRocketMqConsumer
 * @Description rocketmq消息父类
 */
@Slf4j
public abstract class AbstractMiddleRocketMqConsumer implements SmartLifecycle {

    @Value("${rocketmq.nameserver:172.40.240.181:9876}")
    private String nameserver;

    @Value("${rocketmq.tag:*}")
    private String tag;

    @Value("${rocketmq.enabled:false}")
    private boolean enabled;

    private DefaultMQPushConsumer consumer;

    private boolean isRunning = false;

    @Override
    public void start() {
        if (enabled) {
            initConsumer();
        } else {
            log.info("rocketmq不初始化");
        }

    }

    public void initConsumer() {
        log.info("初始化rocketmq消息，server=【{}】,topic=【{}】,group=【{}】，tag=【{}】", getNameServer(), getTopic(),
                getConsumerGroup(), getTag());
        consumer = new DefaultMQPushConsumer(getConsumerGroup());
        consumer.setNamesrvAddr(getNameServer());
        try {
            consumer.subscribe(getTopic(), getTag());
        } catch (MQClientException e) {
            log.error("topic=【{}】,消费者初始化异常，【{}】", getTopic(), e);
            throw new BusinessException("消费者初始化异常");
        }

        consumer.registerMessageListener((MessageListenerConcurrently) (msgs, context) -> {
            if (CollectionUtils.isEmpty(msgs)) {
                log.info("消息列表为空");
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            }
            for (MessageExt msg : msgs) {
                try {
                    handler(msg);
                } catch (Exception e) {
                    log.error("消息处理异常，【{}】", e);
                }
            }
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        });
        try {
            consumer.start();
        } catch (MQClientException e) {
            log.error("topic=【{}】,消费者初始化异常，【{}】", getTopic(), e);
            throw new BusinessException("消费者初始化启动异常");
        }
        isRunning = true;
    }


    @PreDestroy
    public void closeConsumer() {
        consumer.shutdown();
    }

    protected abstract void handler(MessageExt msg);

    protected String getTag() {
        return tag;
    }


    protected abstract String getTopic();

    /**
     * 服务名称
     */
    protected String getNameServer() {
        return nameserver;
    }

    /**
     * 获取分组信息
     */
    protected abstract String getConsumerGroup();

    @Override
    public void stop() {

    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }

}

消费者实现类1 监听topic1的消息

/**
 * @Author 
 * @Date 2023/8/115:53
 * @CLassName PlanMsgConsumer
 * @Description 
 */
@Component
@Slf4j
public class DefectMsgRocketMqConsumer extends AbstractMiddleRocketMqConsumer {

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

    @Value("${rocketmq.enabled:false}")
    private boolean enabled;

    @Value("${rocketmq.defectgroup:GID-defectgroup}")
    private String group;

    @Autowired
    private AddPatrolWorkTaskPublisher patrolWorkTaskPublisher;

    @Override
    protected void handler(MessageExt msg) {
        if (!enabled) {
            log.info("消费kafka消息开关关闭");
            return;
        }
        try {
            log.info("变更消息=【{}】", msg);
           //业务处理
        } catch (Exception e) {
            log.error("变更消息处理异常，【{}】", e);
        }

    }
    @Override
    protected String getConsumerGroup() {
        return group;
    }


    @Override
    protected String getTopic() {
        return topic;
    }

}

消费者实现类2 监听topic2的消息

/**
 * @Author 
 * @Date 2023/8/115:53
 * @CLassName PlanMsgConsumer
 * @Description
 */
@Component
@Slf4j
public class PlanMsgRocketMqConsumer extends AbstractMiddleRocketMqConsumer {

    @Value("${rocketmq.plantopic:}")
    private String topic;

    @Value("${rocketmq.enabled:false}")
    private boolean enabled;

    @Value("${rocketmq.plangroup:GID-plangroup}")
    private String group;


    @Autowired
    private AddPatrolWorkTaskPublisher patrolWorkTaskPublisher;


    @Override
    protected void handler(MessageExt msg) {
        if (!enabled) {
            log.info("消费kafka消息开关关闭");
            return;
        }
        log.info("变更消息=【{}】", msg);
        //业务处理
    }

    @Override
    protected String getConsumerGroup() {
        return group;
    }

    @Override
    protected String getTopic() {
        return topic;
    }

}

生产者

//生产者

 @Value("${rocketmq.nameserver:172.40.240.181:9876}")
    private String nameserver;


    @Value("${rocketmq.tag:*}")
    private String tag;

    @PostMapping("/test/sendRocketMq")
    MiddleResponse<String> sendRocketMq(@RequestBody TestMsgDTO testMsgDTO) throws MQClientException {
        DefaultMQProducer defaultMQProducer = new DefaultMQProducer(testMsgDTO.getGroup());
        defaultMQProducer.setNamesrvAddr(nameserver);
        defaultMQProducer.start();
        Message msg = new Message(testMsgDTO.getTopicName(), tag, testMsgDTO.getMsg().getBytes());
        try {
            defaultMQProducer.sendOneway(msg);
        } catch (RemotingException e) {
            log.error("rocketmq消息发送失败,【{}】", e);
        } catch (InterruptedException e) {
            log.error("rocketmq消息发送失败,【{}】", e);
        }
        return MiddleResponse.successResult("发送成功");
    }