springboot配置rocketmq

1、maven依赖

<!--消息框架rocketmq-->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-common</artifactId>
    <version>4.7.1</version>
</dependency>
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-acl</artifactId>
    <version>4.7.1</version>
</dependency>
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.7.1</version>
</dependency>

2、生产者消费者配置

/**
 * 生产者配置
 */
@Configuration
@ConditionalOnProperty(prefix ="rocketmq.producer",value = "isOnOff",havingValue ="on")
public class RocketmqProducerConfig {

    private static final Logger _LOGGER= LoggerFactory.getLogger(RocketmqProducerConfig.class);
    @Value("${rocketmq.producer.groupName}")
    private String groupName;
    @Value("${rocketmq.producer.nameServAddr}")
    private String nameServAddr;
    @Value("${rocketmq.producer.maxMessageSize}")
    private Integer maxMessageSize;
    @Value("${rocketmq.producer.sendMsgTimeout}")
    private Integer sendMsgTimeout;
    @Value("${rocketmq.producer.retryTimesWhenSendFailed}")
    private Integer retryTimesWhenSendFailed;
    @Value("${rocketmq.acl.accessKey}")
    private String accessKey;
    @Value("${rocketmq.acl.secretKey}")
    private String secretKey;
    @Bean
    public DefaultMQProducer defaultMQProducer() throws MQClientException {
        _LOGGER.info("rocketmq  produce server   正在创建 --------------------------------------------");
        DefaultMQProducer defaultMQProducer=new DefaultMQProducer(groupName,new AclClientRPCHook(new SessionCredentials(accessKey,secretKey)));
        defaultMQProducer.setNamesrvAddr(nameServAddr);
        defaultMQProducer.setVipChannelEnabled(false);
        defaultMQProducer.setMaxMessageSize(maxMessageSize);
        defaultMQProducer.setSendMsgTimeout(sendMsgTimeout);
        defaultMQProducer.setRetryTimesWhenSendFailed(retryTimesWhenSendFailed);
        defaultMQProducer.setUnitName("yc_ai_cm");
        defaultMQProducer.setInstanceName("ai_cm");
        defaultMQProducer.start();
        _LOGGER.info("rocketmq  produce server 创建成功 -------------------------------------------------");
        return defaultMQProducer;
    }
}

/**
 * 消费者配置
 * @author gaozhiwei
 */
@Configuration
@ConditionalOnProperty(prefix ="rocketmq.consumer",value = "isOnOff",havingValue ="on")
public class RocketmqConsumerConfig {

    private static final Logger _LOGGER= LoggerFactory.getLogger(RocketmqConsumerConfig.class);
    @Value("${rocketmq.consumer.nameServAddr}")
    private String nameServAddr;
    @Value("${rocketmq.consumer.groupName}")
    private String groupName;
    @Value("${rocketmq.consumer.consumeThreadMin}")
    private int consumeThreadMin;
    @Value("${rocketmq.consumer.consumeThreadMax}")
    private int consumeThreadMax;
    @Value("${rocketmq.consumer.consumeMessageBatchMaxSize}")
    private int consumeMessageBatchMaxSize;
    @Value("${rocketmq.consumer.retryTimesWhenConsumerFailed}")
    private int retryTimesWhenConsumerFailed;

    @Value("${spring.profiles.active}")
    private String system;

    @Value("${rocketmq.acl.accessKey}")
    private String accessKey;
    @Value("${rocketmq.acl.secretKey}")
    private String secretKey;

    @Resource
    private RocketmqCustomerMsgService mqMsgListener;
    @Bean
    public DefaultMQPushConsumer defaultMQPushConsumer(){
        _LOGGER.info("rocketmq consumer server 正在创建-------------------------------------");
        DefaultMQPushConsumer defaultMQPushConsumer=new DefaultMQPushConsumer(groupName, new AclClientRPCHook(new SessionCredentials(accessKey,secretKey)),
                //平均分配队列算法 hash
                new AllocateMessageQueueAveragely());
        defaultMQPushConsumer.setNamesrvAddr(nameServAddr);
        defaultMQPushConsumer.setConsumeThreadMin(consumeThreadMin);
        defaultMQPushConsumer.setConsumeThreadMax(consumeThreadMax);
        defaultMQPushConsumer.registerMessageListener(mqMsgListener);
        defaultMQPushConsumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        defaultMQPushConsumer.setMessageModel(MessageModel.BROADCASTING);
        defaultMQPushConsumer.setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
        defaultMQPushConsumer.setMaxReconsumeTimes(retryTimesWhenConsumerFailed);
        defaultMQPushConsumer.setVipChannelEnabled(false);
        defaultMQPushConsumer.setUnitName("yc_ai_cm");
        defaultMQPushConsumer.setInstanceName("ai_cm");
        try {
            String topic = MqConstant.Topic.AICM_PUB_MESSAGE+system;
            defaultMQPushConsumer.subscribe(topic,"*");
            defaultMQPushConsumer.start();
            _LOGGER.info("rocketmq consumer server 创建成功--------------------------------------------------");
        }catch (MQClientException e){
            _LOGGER.error("rocketmq consumer server exception ",e);
            e.getErrorMessage();
        }

        return defaultMQPushConsumer;
    }
}

3、消费者消息监听类

/**
 * 消费者消息监听类
 * @author gaozhiwei
 */
@Component
public class RocketmqCustomerMsgService implements MessageListenerConcurrently {

    private static final Logger _LOGGER= LoggerFactory.getLogger(RocketmqCustomerMsgService.class);

    private ICustomerRocketmqMessageListener listener;

    @Value("${rocketmq.consumer.retryTimesWhenConsumerFailed}")
    private int retryTimesWhenConsumerFailed;

    public void addMessageListener(ICustomerRocketmqMessageListener listener) {
        this.listener = listener;
    }


    @Override
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {
        if(CollectionUtils.isEmpty(list)){
            _LOGGER.warn("rocketmq customer 收到的消息为空");
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
        _LOGGER.info("rocketmq customer 收到的消息为[{}]", JSON.toJSONString(list));
        MessageExt messageExt = list.get(0);
        try {
            String topic = messageExt.getTopic();
            String tags = messageExt.getTags();
            String body = new String(messageExt.getBody(), StandardCharsets.UTF_8);
            CustomerMsgRocketMqBo rocketMqBo = new CustomerMsgRocketMqBo(topic, tags, body);
            if (this.listener != null) {
                listener.onMessage(rocketMqBo);
            }
            _LOGGER.info("rocketmq customer success topic[{}],tags[{}],msgId[{}],body[{}]", topic, tags, messageExt.getMsgId(), body);
        } catch (Exception e) {
            _LOGGER.error("customer 获取rocketmq 消息内容异常", e);
            e.printStackTrace();
            if (messageExt.getReconsumeTimes() == retryTimesWhenConsumerFailed) {
                _LOGGER.debug("消费次数[{}],消息[{}]", retryTimesWhenConsumerFailed, JSON.toJSONString(messageExt));
                return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
            } else {
                _LOGGER.debug("消费失败,请重试!!!");
                return ConsumeConcurrentlyStatus.RECONSUME_LATER;
            }
        }
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }
}

/**
 * @author gaozhiwei
 */

public class CustomerMsgRocketMqBo<T> implements Serializable {
    private String topic;

    private String tags;

    public CustomerMsgRocketMqBo(String topic, String tags, T body) {
        this.topic = topic;
        this.tags = tags;
        this.body = body;
    }

    private T body;

    public String getTopic() {
        return topic;
    }

    public void setTopic(String topic) {
        this.topic = topic;
    }

    public String getTags() {
        return tags;
    }

    public void setTags(String tags) {
        this.tags = tags;
    }

    public T getBody() {
        return body;
    }

    public void setBody(T body) {
        this.body = body;
    }

    @Override
    public String toString() {
        return "CustomerMsgRocketMqBo{" +
                "topic='" + topic + ''' +
                ", tags='" + tags + ''' +
                ", body=" + body +
                '}';
    }
}

/**
 * @author gaozhiwei
 */
public interface ICustomerRocketmqMessageListener {

    /**
     * 消费消息
     * @param mqBo
     * @return
     */
    boolean onMessage(CustomerMsgRocketMqBo mqBo);
}

4、工具类

/**
 * @author gaozhiwei
 */
@Component
public class RocketMqUtils {

    /**
     * 日志
     */
    private static final Logger LOG = LoggerFactory.getLogger(RocketMqUtils.class);

    /**
     * rocketmq模板注入
     */
    @Autowired(required = false)
    private DefaultMQProducer defaultMQProducer;

    /**
     * 发送普通消息
     * @param topic
     * @param tags
     * @param body
     * @param <T>
     * @return
     */
    public <T> boolean sendMessage(String topic,String tags, T  body){
        try {
            LOG.info("rocketmq 开始发送消息========");
            Message message = new Message(topic,tags, JSON.toJSONBytes(body));
            SendResult sendResult = defaultMQProducer.send(message);
            if(sendResult!=null){
                LOG.info("rocketmq 消息发送成功========响应状态[{}]",sendResult.getSendStatus());
                LOG.info("rocketmq 消息发送响应消息[{}]",sendResult.toString());
                return true;
            }else {
                return false;
            }
        }catch (Exception e){
            LOG.error("rocketmq 发送消息异常",e);
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 发送延迟消息
     * @param topic
     * @param tags
     * @param body
     * @param <T>
     * @return
     */
    public <T> boolean sendDelayMessage(String topic,String tags, T  body,int delay){
        try {
            LOG.info("rocketmq 开始发送消息========");
            Message message = new Message(topic,tags, JSON.toJSONBytes(body));
            //1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
            message.setDelayTimeLevel(delay);
            int SEND_TIMEOUT = 20000;
            SendResult sendResult = defaultMQProducer.send(message, SEND_TIMEOUT);
            if(sendResult!=null){
                LOG.info("rocketmq 消息发送成功========响应状态[{}]",sendResult.getSendStatus());
                LOG.info("rocketmq 消息发送响应消息[{}]",sendResult.toString());
                return true;
            }else {
                return false;
            }
        }catch (Exception e){
            LOG.error("rocketmq 发送消息异常",e);
            e.printStackTrace();
            return false;
        }

    }
}

5、使用

接收消息

@Autowired
RocketmqCustomerMsgService rocketmqCustomerMsgService;

@Resource(name = "rocketMqExcutor")
private Executor executor;

@Bean
public void initQueueCacheMessageListener(){
    rocketmqCustomerMsgService.addMessageListener(new ICustomerRocketmqMessageListener() {
        @Override
        public boolean onMessage(CustomerMsgRocketMqBo mqBo) {
            if (mqBo.getBody() != null) {
                String message = (String) mqBo.getBody();
                RocketMqMessage rocketMqMessage = JSONObject.parseObject(message, RocketMqMessage.class);
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        if(MqMessageTypeEnum.reloadCorrection.getCode().equals(rocketMqMessage.getMessageType())){
                            queryCorrectionService.getPinyinMap();//
                        }
                    }
                });
            }
            return true;
        }
    });
}